LogResult external type

LogResult contains functions that are invoked by the EUnit test framework, by custom test cases that run in the EUnit test framework, or by both.

Package

org.eclipse.edt.eunit.runtime

Example use
Type detail
Library LogResult

   private outR Log;
   private s Status;	

   private const ACTUALHEADER string = "Actual value = ";
   private const EXPECTEDHEADER string = "Expected value = ";
   private const ACTUALSIZEHEADER string = "Actual array size = ";
   private const EXPECTEDSIZEHEADER string = "Exepcted array size = ";

   /* remove all messages in the log to this point, 
    * but leave the result data unaffected.
   function clearResults()
      outR.msg = "";
      s.code = -1;
      s.reason = "";
   end
	
   // used by the EUnit framework; do not use.
   function getStatus() returns (Status)
      return (s);
   end
	
   // used by the EUnit framework; do not use.
   function getLog() returns(Log)
      return (outR);
   end

   /**
    * write a new line to the log
    */
   function logStdOut(logmsg String in)
      outR.msg += ConstantsLib.NEWLINE;
      outR.msg += logmsg;
   end

   /**
     * set status as passed, specifying text that defaults to "OK"
     */
   function passed(str String in)
      s.code = ConstantsLib.SPASSED;

      if(str == null || str == "")
         str = "OK";
      end
      s.reason = str;
   end

   /**
     * set status as failed, specifying text that is appended to "Failed"
     */
   function failed(str String in)
      s.code = ConstantsLib.SFAILED;
      str = "FAILED - " + str;
      s.reason = str;
   end
	
   // set this to specify a different category of mistake; 
   // the input string is logged, and the test case ends with an "error"
   // rather than failure.
   function error(str String in)
      s.code = ConstantsLib.SERROR;
      str = "ERROR - " + str;
      s.reason = str;
   end

   // indicates that the test case was skipped
   function skipped(str String in)
      s.code = ConstantsLib.SNOT_RUN;
      str = "SKIPPED - " + str;
      s.reason = str;
   end

   private function assertTrueException(
                             failedReason String in, 
                             testCondition boolean in, 
                             throwsFailException boolean in)

      if(testCondition)
         passed("OK");
      else
         failed(failedReason);

         if(throwsFailException)
            throw new AssertionFailedException{message = s.reason};
         end
      end
   end	

   /**
     * assertTrue: a particularly useful function that tests a condition 
     * and throws AssertionFailedException when the condition is false.
     *
     * @param failedReason String - if assertion failed, 
     *                              the failure reason message
     * 
     * @param testCondition boolean in - in parameter, assert 
     *                                   if testCondition is true
     *
     * @throws AssertionFailedException when testCondition is false
     **/
   function assertTrue(failedReason String in, testCondition boolean in)
      assertTrueException(failedReason, testCondition, true);
   end	

   /**
     * @description method to pass in empty string for the failed reason, 
                    so the report will only state "FAILED"
     * @throws AssertionFailedException when testCondition is false
    **/
   function assertTrue1(testCondition boolean in)
      assertTrue("", testCondition);
   end

   /**
     * @description - message will be prepended 
                      to the standard expected and actual messages
    **/
   function assertBigIntEqual(message String in, 
                              expected bigint in, 
                              actual bigint in)
      isEqual boolean = (expected == actual);
      expectAssertTrue(message, expected, actual, isEqual);
   end

   function assertBigIntEqual1(expected bigint in, actual bigint in)
      assertBigIntEqual("", expected, actual);
   end

   function assertStringEqual(message String in, 
                              expected String in, 
                              actual String in)
      isEqual boolean = (expected == actual);
      expectAssertTrue(message, expected, actual, isEqual);
   end

   function assertStringEqual1(expected String in, actual String in)
      assertStringEqual("", expected, actual);
   end

   function assertStringArrayEqual(message String in, 
                                   expected String[] in, 
                                   actual String[] in)

      isArrayEqual boolean = true;
      expectedSize int = expected.getSize();
      actualSize int = actual.getSize();
      failedReason String;

      if(expectedSize == actualSize)
         failedHeader String = "Array element No.[";
         expectedValues String = EXPECTEDHEADER + "[";
         actualValues String = ACTUALHEADER + "[";

         for(i int from 1 to expectedSize)

            if(expected[i] != actual[i])
               if(!isArrayEqual)
                  failedHeader += ", ";
               end

               isArrayEqual = false;
               failedHeader += i as String;
            end

            expectedValues += expected[i];
            actualValues += actual[i];

            if(i != expectedSize)
               expectedValues += ", ";
               actualValues += ", ";
            end
         end // for

         failedHeader += "] differs; ";
         expectedValues += "]; ";
         actualValues += "] ";
         failedReason = failedHeader + expectedValues + actualValues;
      else
         isArrayEqual = false;
         failedReason = "Failed: " + EXPECTEDSIZEHEADER + "'" + expectedSize + 
                        "' " + ACTUALSIZEHEADER + "'" + actualSize + "' ";
      end

      if(message != null && message != "");
         failedReason = message + " - " + failedReason;
      end
      
      assertTrue(failedReason, isArrayEqual);
   end

   function assertStringArrayEqual1(expected String[] in, actual String[] in)
      assertStringArrayEqual("", expected, actual);
   end

   function assertDateEqual(message String in,
                            expected Date in,
                            actual Date in)
      isEqual boolean = (expected == actual);
      expectAssertTrue(message, expected, actual, isEqual);
   end

   function assertDateEqual1(expected Date in, actual Date in)
      assertDateEqual("", expected, actual);
   end

   function assertTimestampEqual(message String in, 
                                 expected Timestamp in, 
                                 actual Timestamp in)
      isEqual boolean = (expected == actual);
      expectAssertTrue(message, expected, actual, isEqual);
   end
	
   function assertTimestampEqual1(expected Timestamp in, actual Timestamp in)
      assertTimestampEqual("", expected, actual);
   end

   function assertDecimalEqual(message String in, 
                               expected decimal in, 
                               actual decimal in)
      isEqual boolean = (expected == actual);
      expectAssertTrue(message, expected, actual, isEqual);
   end

   function assertDecimalEqual1(expected decimal in, actual decimal in)
      assertDecimalEqual("", expected, actual);
   end

   function assertFloatEqual(message String in, 
                             expected float in, 
                             actual float in)

      isEqual boolean = isFloatEqual(expected, actual);
      expectAssertTrue(message, expected, actual, isEqual);
   end

   function assertFloatEqual1(expected float in, actual float in)
      assertFloatEqual("", expected, actual);
   end

   //private helper methods
   private function isFloatEqual(expected float in, 
                                 actual float in) returns (boolean)

      normalExpected, normalActual, delta float;
      mantissaExpected, mantissaActual int;
      signExpected, signActual String;
      deltaLimit float = 1E-14;
      normalExpected = normalFloat(expected, mantissaExpected, signExpected);
      normalActual = normalFloat(actual, mantissaActual, signActual);
      delta = normalExpected - normalActual;
      delta = MathLib.abs(delta);

      isEqual boolean = (signExpected == signActual) &&
                        (mantissaExpected == mantissaActual) &&
                        (delta < deltaLimit);

      return(isEqual);	
   end	

   private function expectAssertTrue(message String in, 
                                     expected any in, 
                                     actual any in, isEqual boolean in)
      failedReason String = buildFailedReason(message, expected, actual);
      assertTrue(failedReason, isEqual);
   end

   private function buildFailedReason(message String in, 
                                      expected any in, actual any in) 
                                      returns (String)

      failedReason String = expect(expected, actual);

      if(message != null && message != "")
         failedReason = message + " - " + failedReason;
      end
      return (failedReason);
   end

   private function expect(expected any in, actual any in) returns (String)
      standardMsg string = "Failed: " + EXPECTEDHEADER + 
                           "'" + expected + "' " + 
                           ACTUALHEADER + "'" + actual + "' ";
      return (standardMsg);
   end

   private function normalFloat(afloat float in, 
                                mantissa int out, sign string out) 
                                returns(float)
      mantissa = 0;

      if(aFloat >= 0)
         sign = "+";
      else
         sign = "-";
         aFloat = aFloat * -1;
      end

      if(aFloat != null && aFloat != 0)

         while(aFloat < 1)
            aFloat = aFloat * 10;
            mantissa = mantissa - 1;
         end

         while(aFloat >= 10)
            aFloat = aFloat / 10;
            mantissa = mantissa + 1;
         end
      end
      return(aFloat);
   end
end
Comments

For a description of how to use the framework, see Developing and running test cases with EUnit.

Compatibility

Table 1. Compatibility
Target Issue
Java No issues.
JavaScript No issues.