@Test
  @Named("null if spec description is empty")
  @Order(1)
  public void _nullIfSpecDescriptionIsEmpty() throws Exception {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("package test");
    _builder.newLine();
    _builder.append("describe \"\"{}");
    this._modelStore.parseSpec(_builder);
    String _qualifiedName = this.qualifiedName();
    Matcher<String> _nullValue = CoreMatchers.<String>nullValue();
    boolean _should_be = Should.<String>should_be(_qualifiedName, _nullValue);
    Assert.assertTrue(
        "\nExpected qualifiedName should be null but"
            + "\n     qualifiedName is "
            + new StringDescription().appendValue(_qualifiedName).toString()
            + "\n",
        _should_be);

    StringConcatenation _builder_1 = new StringConcatenation();
    _builder_1.append("describe \"\"{}");
    this._modelStore.parseSpec(_builder_1);
    String _qualifiedName_1 = this.qualifiedName();
    Matcher<String> _nullValue_1 = CoreMatchers.<String>nullValue();
    boolean _should_be_1 = Should.<String>should_be(_qualifiedName_1, _nullValue_1);
    Assert.assertTrue(
        "\nExpected qualifiedName should be null but"
            + "\n     qualifiedName is "
            + new StringDescription().appendValue(_qualifiedName_1).toString()
            + "\n",
        _should_be_1);
  }
  @Test
  @Named("if waiting for response")
  @Order(1)
  public void _ifWaitingForResponse() throws Exception {
    boolean _isBusy = this.subject.isBusy();
    boolean _doubleArrow = Should.<Boolean>operator_doubleArrow(Boolean.valueOf(_isBusy), false);
    Assert.assertTrue(
        "\nExpected subject.busy => false but"
            + "\n     subject.busy is "
            + new org.hamcrest.StringDescription().appendValue(Boolean.valueOf(_isBusy)).toString()
            + "\n     subject is "
            + new org.hamcrest.StringDescription().appendValue(this.subject).toString()
            + "\n",
        _doubleArrow);

    final Answer<Callback<Response>> _function =
        new Answer<Callback<Response>>() {
          public Callback<Response> answer(final InvocationOnMock it) throws Throwable {
            Object[] _arguments = it.getArguments();
            Object _get = _arguments[1];
            return ConnectorBusySpec.this.callback = ((Callback) _get);
          }
        };
    Stubber _doAnswer = Mockito.doAnswer(_function);
    Connection _when = _doAnswer.<Connection>when(this.connection);
    Command _any = Matchers.<Command>any();
    Callback _any_1 = Matchers.<Callback>any();
    _when.<Response>sendRequest(_any, _any_1);
    this.subject.<Response>execute(this.anyCommand, this.callback);
    boolean _isBusy_1 = this.subject.isBusy();
    boolean _doubleArrow_1 = Should.<Boolean>operator_doubleArrow(Boolean.valueOf(_isBusy_1), true);
    Assert.assertTrue(
        "\nExpected subject.busy => true but"
            + "\n     subject.busy is "
            + new org.hamcrest.StringDescription()
                .appendValue(Boolean.valueOf(_isBusy_1))
                .toString()
            + "\n     subject is "
            + new org.hamcrest.StringDescription().appendValue(this.subject).toString()
            + "\n",
        _doubleArrow_1);

    Response _response = new Response(0, "");
    this.callback.handleResponse(_response);
    boolean _isBusy_2 = this.subject.isBusy();
    Assert.assertTrue(
        "\nExpected subject.busy => false but"
            + "\n     subject.busy is "
            + new org.hamcrest.StringDescription()
                .appendValue(Boolean.valueOf(_isBusy_2))
                .toString()
            + "\n     subject is "
            + new org.hamcrest.StringDescription().appendValue(this.subject).toString()
            + "\n",
        Should.<Boolean>operator_doubleArrow(Boolean.valueOf(_isBusy_2), false));
  }
 @Test
 @Named("returns the name for a step with resolved reference")
 @Order(3)
 public void _returnsTheNameForAStepWithResolvedReference() throws Exception {
   StringConcatenation _builder = new StringConcatenation();
   _builder.append("Scenario: MyScenario 2");
   _builder.newLine();
   _builder.append("\t");
   _builder.append("Given a step with a resolved reference");
   _builder.newLine();
   _builder.append("Scenario: MyScenario 1");
   _builder.newLine();
   _builder.append("\t");
   _builder.append("Given a step with a resolved reference");
   _builder.newLine();
   _builder.append("\t\t");
   _builder.append("\"implementation\"");
   _builder.newLine();
   this.parseScenario(_builder);
   String _stepName = this.stepName();
   boolean _doubleArrow =
       Should.operator_doubleArrow(_stepName, "Given a step with a resolved reference");
   Assert.assertTrue(
       "\nExpected stepName => \"Given a step with a resolved reference\" but"
           + "\n     stepName is "
           + new StringDescription().appendValue(_stepName).toString()
           + "\n",
       _doubleArrow);
 }
  @Test
  @Named("Receives progress from server")
  @Order(5)
  public void _receivesProgressFromServer() throws Exception {
    ArrayList<String> _responses = this.server.getResponses();
    _responses.add(this.progressMessage);
    ArrayList<String> _responses_1 = this.server.getResponses();
    _responses_1.add(this.responseMessage);
    this.subject.connect(this.ADDRESS, this.PORT);
    this.subject.<Response>sendRequest(Commands.ANY_COMMAND, this.callback);
    final Function1<WaitConfig, Boolean> _function =
        new Function1<WaitConfig, Boolean>() {
          public Boolean apply(final WaitConfig it) {
            Response _response = TcpClientSendingRequestsSpec.this.callback.getResponse();
            return Boolean.valueOf((!Objects.equal(_response, null)));
          }
        };
    Wait.waitUntil(_function);
    List<Progress> _progress = this.callback.getProgress();
    int _size = _progress.size();
    boolean _doubleArrow =
        Should.<Integer>operator_doubleArrow(Integer.valueOf(_size), Integer.valueOf(1));
    Assert.assertTrue(
        "\nExpected callback.progress.size => 1 but"
            + "\n     callback.progress.size is "
            + new org.hamcrest.StringDescription().appendValue(Integer.valueOf(_size)).toString()
            + "\n     callback.progress is "
            + new org.hamcrest.StringDescription().appendValue(_progress).toString()
            + "\n     callback is "
            + new org.hamcrest.StringDescription().appendValue(this.callback).toString()
            + "\n",
        _doubleArrow);

    Response _response = this.callback.getResponse();
    final Procedure1<Response> _function_1 =
        new Procedure1<Response>() {
          public void apply(final Response it) {
            String _type = it.getType();
            Assert.assertTrue(
                "\nExpected type => \"response\" but"
                    + "\n     type is "
                    + new org.hamcrest.StringDescription().appendValue(_type).toString()
                    + "\n",
                Should.<String>operator_doubleArrow(_type, "response"));
          }
        };
    ObjectExtensions.<Response>operator_doubleArrow(_response, _function_1);
  }
 @Test
 @Named("uses referenced type")
 @Order(4)
 public void _usesReferencedType() throws Exception {
   StringConcatenation _builder = new StringConcatenation();
   _builder.append("describe org.junit.Assert{}");
   this._modelStore.parseSpec(_builder);
   String _qualifiedName = this.qualifiedName();
   boolean _doubleArrow = Should.operator_doubleArrow(_qualifiedName, "Assert");
   Assert.assertTrue(
       "\nExpected qualifiedName => \"Assert\" but"
           + "\n     qualifiedName is "
           + new StringDescription().appendValue(_qualifiedName).toString()
           + "\n",
       _doubleArrow);
 }
 @Test
 @Named("trims spec description whitespace")
 @Order(3)
 public void _trimsSpecDescriptionWhitespace() throws Exception {
   StringConcatenation _builder = new StringConcatenation();
   _builder.append("describe \"My Spec  \"{}");
   this._modelStore.parseSpec(_builder);
   String _qualifiedName = this.qualifiedName();
   boolean _doubleArrow = Should.operator_doubleArrow(_qualifiedName, "My Spec");
   Assert.assertTrue(
       "\nExpected qualifiedName => \"My Spec\" but"
           + "\n     qualifiedName is "
           + new StringDescription().appendValue(_qualifiedName).toString()
           + "\n",
       _doubleArrow);
 }
 @Test
 @Named("implementedStep.isPending[] should be false")
 @Order(2)
 public void _implementedStepIsPendingShouldBeFalse() throws Exception {
   Given _implementedStep = Features.implementedStep();
   boolean _isPending = _implementedStep.isPending();
   boolean _should_be = Should.<Boolean>should_be(Boolean.valueOf(_isPending), false);
   Assert.assertTrue(
       "\nExpected implementedStep.isPending() should be false but"
           + "\n     implementedStep.isPending() is "
           + new StringDescription().appendValue(Boolean.valueOf(_isPending)).toString()
           + "\n     implementedStep is "
           + new StringDescription().appendValue(_implementedStep).toString()
           + "\n",
       _should_be);
 }
 @Test
 @Named("stepWithoutImplementation.isPending[] should be true")
 @Order(1)
 public void _stepWithoutImplementationIsPendingShouldBeTrue() throws Exception {
   Given _stepWithoutImplementation = Features.stepWithoutImplementation();
   boolean _isPending = _stepWithoutImplementation.isPending();
   boolean _should_be = Should.<Boolean>should_be(Boolean.valueOf(_isPending), true);
   Assert.assertTrue(
       "\nExpected stepWithoutImplementation.isPending() should be true but"
           + "\n     stepWithoutImplementation.isPending() is "
           + new StringDescription().appendValue(Boolean.valueOf(_isPending)).toString()
           + "\n     stepWithoutImplementation is "
           + new StringDescription().appendValue(_stepWithoutImplementation).toString()
           + "\n",
       _should_be);
 }
 @Test
 @Named("returns null if the step has no name")
 @Order(1)
 public void _returnsNullIfTheStepHasNoName() throws Exception {
   Given _emptyStep = this.emptyStep();
   String _nameOf = this.subject.nameOf(_emptyStep);
   boolean _equals = Objects.equal(_nameOf, null);
   Assert.assertTrue(
       "\nExpected subject.nameOf(emptyStep) == null but"
           + "\n     subject.nameOf(emptyStep) is "
           + new StringDescription().appendValue(_nameOf).toString()
           + "\n     subject is "
           + new StringDescription().appendValue(this.subject).toString()
           + "\n     emptyStep is "
           + new StringDescription().appendValue(_emptyStep).toString()
           + "\n",
       _equals);
 }
Example #10
0
 @Test
 @Named("Root Specs pass")
 @Order(3)
 public void _rootSpecsPass() throws Exception {
   IEObjectDescription _rootSpec = this.rootSpec();
   boolean _apply = this.subject.apply(_rootSpec);
   boolean _doubleArrow =
       Should.operator_doubleArrow(Boolean.valueOf(_apply), Boolean.valueOf(true));
   Assert.assertTrue(
       "\nExpected subject.apply(rootSpec) => true but"
           + "\n     subject.apply(rootSpec) is "
           + new StringDescription().appendValue(Boolean.valueOf(_apply)).toString()
           + "\n     subject is "
           + new StringDescription().appendValue(this.subject).toString()
           + "\n     rootSpec is "
           + new StringDescription().appendValue(_rootSpec).toString()
           + "\n",
       _doubleArrow);
 }
Example #11
0
 @Test
 @Named("Child Specs fail")
 @Order(4)
 public void _childSpecsFail() throws Exception {
   IEObjectDescription _childSpec = this.childSpec();
   boolean _apply = this.subject.apply(_childSpec);
   boolean _doubleArrow =
       Should.operator_doubleArrow(Boolean.valueOf(_apply), Boolean.valueOf(false));
   Assert.assertTrue(
       "\nExpected subject.apply(childSpec) => false but"
           + "\n     subject.apply(childSpec) is "
           + new StringDescription().appendValue(Boolean.valueOf(_apply)).toString()
           + "\n     subject is "
           + new StringDescription().appendValue(this.subject).toString()
           + "\n     childSpec is "
           + new StringDescription().appendValue(_childSpec).toString()
           + "\n",
       _doubleArrow);
 }
Example #12
0
 @Test
 @Named("Features pass")
 @Order(2)
 public void _featuresPass() throws Exception {
   EClass _feature = this._featurePackage.getFeature();
   IEObjectDescription _desc = this.desc(_feature);
   boolean _apply = this.subject.apply(_desc);
   boolean _doubleArrow =
       Should.operator_doubleArrow(Boolean.valueOf(_apply), Boolean.valueOf(true));
   Assert.assertTrue(
       "\nExpected subject.apply(desc(feature)) => true but"
           + "\n     subject.apply(desc(feature)) is "
           + new StringDescription().appendValue(Boolean.valueOf(_apply)).toString()
           + "\n     subject is "
           + new StringDescription().appendValue(this.subject).toString()
           + "\n     desc(feature) is "
           + new StringDescription().appendValue(_desc).toString()
           + "\n     feature is "
           + new StringDescription().appendValue(_feature).toString()
           + "\n",
       _doubleArrow);
 }
 @Test
 @Named("Throws exception if not connected")
 @Order(6)
 public void _throwsExceptionIfNotConnected() throws Exception {
   boolean expectedException = false;
   String message = "";
   try {
     this.subject.<Response>sendRequest(Commands.ANY_COMMAND, this.callback);
     message =
         "Expected "
             + BackendException.class.getName()
             + " for \n     subject.sendRequest(ANY_COMMAND, callback)\n with:"
             + "\n     subject is "
             + new org.hamcrest.StringDescription().appendValue(this.subject).toString()
             + "\n     ANY_COMMAND is "
             + new org.hamcrest.StringDescription().appendValue(Commands.ANY_COMMAND).toString()
             + "\n     callback is "
             + new org.hamcrest.StringDescription().appendValue(this.callback).toString();
   } catch (BackendException e) {
     expectedException = true;
   }
   Assert.assertTrue(message, expectedException);
 }
 @Test
 @Named("Notifies callback when command is sent")
 @Order(4)
 public void _notifiesCallbackWhenCommandIsSent() throws Exception {
   ArrayList<String> _responses = this.server.getResponses();
   _responses.add(this.responseMessage);
   this.subject.connect(this.ADDRESS, this.PORT);
   this.subject.<Response>sendRequest(Commands.ANY_COMMAND, this.callback);
   final Function1<WaitConfig, Boolean> _function =
       new Function1<WaitConfig, Boolean>() {
         public Boolean apply(final WaitConfig it) {
           Response _response = TcpClientSendingRequestsSpec.this.callback.getResponse();
           return Boolean.valueOf((!Objects.equal(_response, null)));
         }
       };
   Wait.waitUntil(_function);
   boolean _hasStarted = this.callback.hasStarted();
   Assert.assertTrue(
       "\nExpected callback.hasStarted but"
           + "\n     callback is "
           + new org.hamcrest.StringDescription().appendValue(this.callback).toString()
           + "\n",
       _hasStarted);
 }
 @Test
 @Named("keeps parameter values")
 @Order(5)
 public void _keepsParameterValues() throws Exception {
   StringConcatenation _builder = new StringConcatenation();
   _builder.append("Scenario: MyScenario 2");
   _builder.newLine();
   _builder.append("\t");
   _builder.append("Given a step with two values \"a\" and \"b\"");
   _builder.newLine();
   _builder.append("\t ");
   _builder.append("1 + 1 => 2");
   _builder.newLine();
   this.parseScenario(_builder);
   String _stepName = this.stepName();
   boolean _doubleArrow =
       Should.operator_doubleArrow(_stepName, "Given a step with two values \"a\" and \"b\"");
   Assert.assertTrue(
       "\nExpected stepName => \'Given a step with two values \"a\" and \"b\"\' but"
           + "\n     stepName is "
           + new StringDescription().appendValue(_stepName).toString()
           + "\n",
       _doubleArrow);
 }