Examples with CommaSeparatedValuesExpectation org.eclipse.xpect.expectation.CommaSeparatedValuesExpectation used on opensource projects

Example 1 with CommaSeparatedValuesExpectation

use of org.eclipse.xpect.expectation.CommaSeparatedValuesExpectation in project n4js by eclipse.

the class ContentAssistXpectMethod method contentAssistList.

/*-
	 contentAssistList              at ’a.<|>methodA’       display    ’methodA2’           --> ’methodA2(): any - A’
	 contentAssistList              at 'a.<|>methodA'       proposals                       --> <$objectProposals>, methodA2
	 contentAssistList              at 'a.<|>methodA'       proposals                       --> <$objectProposals>, methodA2
	 contentAssistList              at 'a.<|>methodA'       proposals                       --> methodA, methodA2
	 contentAssistList              at 'a.<|>methodA'       proposals             contains  --> methodA2
	 contentAssistList              at 'a.<|>methodA'       proposals             exactly   --> methodA, methodA2
	 contentAssistList              at 'a.<|>methodA'       proposals             not       --> methodB
	 contentAssistList              at 'a.<|>methodA'       proposals             ordered   --> methodA, methodA2
	 contentAssistList              at 'a.<|>methodA'       proposals             unordered --> methodA2, methodA
	 contentAssistList              at 'a.<|>methodA'       display   'methodA2'            --> 'methodA2(): any - A'
	 contentAssistList kind 'smart' at 'a.<|>methodA'       display   'methodA2'            --> 'methodA2(): any - A'
	
	                    kind        offset                  checkType  selected    mode
	                    arg4        arg2                    arg3       arg5        arg6
	 */
/**
 * Compares the expected list of expected display strings with the actual computed one by the proposal provider.
 *
 * @param expect
 *            injected from right hand side - a list expected display strings
 * @param resource
 *            injected - the resource under test
 * @param offset
 *            arg2 - the offset of where to invoke content assist given as string matching next line with cursor
 *            position
 * @param checkType
 *            arg3 - one of {proposals | display }
 * @param kind
 *            arg4 - contentAssist - cycling: current kind like 'n4js'(default) or 'recommenders'
 * @param selected
 *            arg5 - chosen selection form the proposal list
 * @param mode
 *            arg6 - depending on checkTye: apply->{insert(default)|override}, proposals->{contains,
 *            exactly(default), not}
 * @param orderMod
 *            arg7 - for proposal-modes contains/exactly there are two mode available{ordered, unordered(default)}
 * @throws Exception
 *             some exception
 */
@Xpect
@ParameterParser(syntax = "( ('kind' arg4=STRING)? 'at' (arg2=STRING (arg3=ID  (arg5=STRING)?  (arg6=ID (arg7=ID)? )? )? )? )?")
@ConsumedIssues({ Severity.INFO, Severity.ERROR, Severity.WARNING })
public void contentAssistList(// arg0
@CommaSeparatedValuesExpectation(quoted = true) ICommaSeparatedValuesExpectation expect, // arg1
@ThisResource XtextResource resource, // arg2 //@ThisOffset is obsolete
RegionWithCursor offset, // arg3
String checkType, // arg4
String kind, // arg5
String selected, // arg6
String mode, // arg7
String orderMod, ISetupInitializer<XpEnvironmentData> uiTestRunInit) throws Exception {
    XpEnvironmentData xpEnvData = new XpEnvironmentData();
    uiTestRunInit.initialize(xpEnvData);
    xpEnvData.setResourceUnderTest(resource);
    // Expansion of Variables. This changes the original expectation:
    CommaSeparatedValuesExpectationImpl csvE = (CommaSeparatedValuesExpectationImpl) expect;
    Pair<CommaSeparatedValuesExpectationImpl, CharSequence> exptectationAndText = expandVariables(csvE, xpEnvData);
    CommaSeparatedValuesExpectationImpl expectation = exptectationAndText.getKey();
    CharSequence expectedText = exptectationAndText.getValue();
    // System.out.println("---|" + expectedText + "|---");
    List<String> proposals = getProposalDisplayStrings(resource, offset, kind);
    if (("display").equals(checkType)) {
        // TODO check original code, seems like errors wehn porting
        // expectation exactly one string:
        // pick the proposal, test that only one is Picked && verify with expectation.
        List<String> candidates = proposals.stream().filter(p -> p.contains(selected)).collect(Collectors.toList());
        if (candidates.size() > 1) {
            StringBuilder sb = new StringBuilder();
            sb.append("more then one proposal matches the selection '").append(selected).append("' matches:[");
            candidates.forEach(m -> sb.append(m).append(","));
            sb.append("]");
            throw new RuntimeException(sb.toString());
        }
        if (candidates.size() == 0) {
            StringBuilder sb = new StringBuilder();
            sb.append("nothing matches the selection '").append(selected).append("' available are [");
            candidates.forEach(m -> sb.append(m).append(","));
            sb.append("]");
            throw new RuntimeException(sb.toString());
        }
        // exactly one:
        expectation.assertEquals(candidates);
        return;
    } else if ("proposals".equals(checkType)) {
        // order-mode, default is 'unordered'
        boolean ordered = ("ordered" == orderMod || "ordered" == mode);
        if (mode == null) {
            if (ordered) {
                assertExactlyOrdered(proposals, separateOnCommaAndQuote(expectedText), expectation);
            } else {
                assertExactly(proposals, separateOnCommaAndQuote(expectedText), expectation);
            }
            return;
        }
        switch(mode) {
            case "":
            // just in case mode is default, then orderMod gets assigned to mode
            case "ordered":
            // just in case mode is default, then orderMod gets assigned to mode
            case "unordered":
            case // default case.
            "exactly":
                if (ordered) {
                    assertExactlyOrdered(proposals, separateOnCommaAndQuote(expectedText), expectation);
                } else {
                    assertExactly(proposals, separateOnCommaAndQuote(expectedText), expectation);
                }
                return;
            case "contains":
                {
                    if (ordered) {
                        assertContainingMatchAllOrdered(proposals, separateOnCommaAndQuote(expectedText), expectation);
                    } else {
                        assertContainingMatchAll(proposals, separateOnCommaAndQuote(expectedText), expectation);
                    }
                    return;
                }
            case "not":
                // ordered / unordered doesn't apply here
                assertNoMatch(proposals, separateOnCommaAndQuote(expectedText), expectation);
                return;
            default:
                throw new RuntimeException("unrecognized mode for proposal-test : '" + mode + "'");
        }
    } else {
        throw new UnsupportedOperationException("unrecognized checktype: '" + checkType + "'");
    }
}