Source: org/terraswarm/accessor/accessors/web/test/TrainableTest.js

  1. // Copyright (c) 2016-2017 The Regents of the University of California.
  2. // All rights reserved.
  3. //
  4. // Permission is hereby granted, without written agreement and without
  5. // license or royalty fees, to use, copy, modify, and distribute this
  6. // software and its documentation for any purpose, provided that the above
  7. // copyright notice and the following two paragraphs appear in all copies
  8. // of this software.
  9. //
  10. // IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
  11. // FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  12. // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  13. // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
  14. // SUCH DAMAGE.
  15. //
  16. // THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  17. // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18. // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
  19. // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
  20. // CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
  21. // ENHANCEMENTS, OR MODIFICATIONS.
  22. //
  23. /** Compare the input with a known good input.
  24.  *  If you set ''trainingMode'' to true and provide inputs, then the
  25.  *  inputs will be recorded in the ''correctValues'' parameters.
  26.  *  Otherwise, the inputs will be compared against those in the
  27.  *  ''correctValue'' parameter.
  28.  *
  29.  *  @accessor test/TrainableTest
  30.  *  @input input The input value.
  31.  *  @output output False as long as there is data to compare against the input
  32.  *  @param correctValues a JSON array of the correct values.
  33.  *  @param trainingMode true if the input is being trained.
  34.  *  @author Christopher Brooks based on the Ptolemy NonStrictTest actor by Paul Whitaker, Christopher Hylands, Edward A. Lee
  35.  *  @version $$Id$$
  36.  */
  38. // Stop extra messages from jslint and jshint.  Note that there should
  39. // be no space between the / and the * and global. See
  40. // https://chess.eecs.berkeley.edu/ptexternal/wiki/Main/JSHint */
  41. /*globals console, exports*/
  42. /*jshint globalstrict: true*/
  43. /*jslint plusplus: true */
  44. 'use strict';
  46. exports.setup = function () {
  47.     this.parameter('correctValues', {
  48.         'value': [0]
  49.     });
  50.     this.input('input');
  51.     this.output('output', {
  52.         'type': 'boolean'
  53.     });
  54.     this.parameter('tolerance', {
  55.         'type': 'number',
  56.         'value': 0.000000001
  57.     });
  58.     this.parameter('trainingMode', {
  59.         'type': 'boolean',
  60.         'value': false
  61.     });
  62. };
  64. // Input, parameter and variable names match those in $PTII/ptolemy/actor/lib/NonStrictTest.java
  66. // Set to true if an input is handled.  If no inputs are handled, then
  67. // throw an exception in wrapup().
  68. var inputHandled = false;
  70. // Set to true when initialize() is called.
  71. var initialized = false;
  73. // The number of input tokens that have been read in.
  74. var numberOfInputTokensSeen = 0;
  76. // If trainingMode is true, then inputs that have been seen so far.
  77. var trainingTokens = [];
  79. // Set to false in initialize() and true at the end of wrapup().
  80. // FIXME: We should have an exit hook that checks that wrapup() is called for all the actors.
  81. var wrappedUp = false;
  83. // So we can test this in hosts/node/test/mocha/testMain.js to test that wrapup was called.
  84. exports.wrappedUp = wrappedUp;
  86. // Return true if the object has the same properties, in any order.
  87. // Based on http://procbits.com/2012/01/19/comparing-two-javascript-objects
  88. var objectPropertiesEqual = function(object1, object2) {
  89.     var property;
  91.     // Check that all the properties in object2 are present in object.
  92.     for ( property in object2) {
  93.         if (typeof object1[property] === 'undefined') {
  94.             return false;
  95.         }
  96.     }
  98.     // Check that all the properties in object1 are preset in object2.
  99.     for (property in object1) {
  100.         if (typeof object2[property] === 'undefined') {
  101.             return false;
  102.         }
  103.     }
  105.     // If a property is an object1, the recursively call this function.
  106.     // If a property is a function, then do a string comparison.
  107.     for (property in object2) {
  108.         if (object2[property]) {
  109.             switch (typeof object2[property]) {
  110.             case 'object1':
  111.                 // Here's the recursive bit
  112.                 if (!objectPropertiesEqual(object1[property], object2[property])) {
  113.                     return false;
  114.                 }
  115.                 break;
  116.             case 'function':
  117.                 if (typeof object1[property] ==='undefined' ||
  118.                     (property != 'object1PropertiesEqual' &&
  119.                      object2[property].toString() != object1[property].toString())) {
  120.                     return false;
  121.                 }
  122.                 break;
  123.             default:
  124.                 if (object2[property] !== object1[property]) {
  125.                     return false;
  126.                 }
  127.             }
  128.         } else {
  129.             // FIXME: I'm not sure if this case is ever used, but it was in 
  130.             // http://procbits.com/2012/01/19/comparing-two-javascript-objects
  131.             if (object1[property]) {
  132.                 return false;
  133.             }
  134.         }
  135.     }
  137.     return true;
  138. };
  140. /** Create an input handler to compare the input with the appropriate element(s)
  141.  *  from correctValues.
  142.  */
  143. exports.initialize = function () {
  144.     //console.log("Test initialize(): typeof correctValues: " + typeof this.getParameter('correctValues'))
  145.     var inputValueValue,
  146.         self = this;
  148.     trainingTokens = [];
  149.     exports.wrappedUp = false;
  150.     numberOfInputTokensSeen = 0;
  152.     this.addInputHandler('input', function () {
  153.         var cache = [],
  154.             inputValue = self.get('input'),
  155.             inputValueValue;
  156.         inputHandled = true;
  158.         // If the input is not connected, then inputValue will be null.
  159.         if (self.getParameter('trainingMode')) {
  160.             trainingTokens.push(inputValue);
  161.             self.send('output', false);
  162.             return;
  163.         }
  164.         var correctValuesValues = self.getParameter('correctValues');
  166.         if (numberOfInputTokensSeen < correctValuesValues.length) {
  167.             var referenceToken = correctValuesValues[numberOfInputTokensSeen];
  168.             //console.log("Test: " + numberOfInputTokensSeen + ", input: " + inputValue
  169.             //+ ", referenceToken: " + referenceToken);
  170.             if (typeof inputValue !== 'boolean' &&
  171.                 typeof inputValue !== 'number' &&
  172.                 typeof inputValue !== 'object' &&
  173.                 typeof inputValue !== 'string') {
  174.                 if (inputValue === null) {
  175.                     throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  176.                                     ' tokens, the value of the input was null?  ' +
  177.                                     'Perhaps the input is not connected?'
  178.                                    );
  179.                 }
  180.                 cache = [];
  181.                 inputValueValue = JSON.stringify(inputValue, function (key, value) {
  182.                     if (typeof value === 'object' && value !== null) {
  183.                         if (cache.indexOf(value) !== -1) {
  184.                             // Circular reference found, discard key
  185.                             return;
  186.                         }
  187.                         // Store value in our collection
  188.                         cache.push(value);
  189.                     }
  190.                     return value;
  191.                 });
  192.                 if (inputValueValue.length > 100) {
  193.                     inputValueValue = inputValueValue.substring(0, 100) + '...';
  194.                 }
  195.                 cache = null; // Enable garbage collection
  198.                 throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  199.                                 ' tokens, the input "' + inputValue +
  200.                                 '" is neither a number nor a string, it is a ' +
  201.                                 typeof inputValue + ' with value ' + inputValueValue);
  202.             }
  203.             if (typeof referenceToken === 'boolean') {
  204.                 // If the input not a boolean, then throw an error.
  205.                 if (typeof inputValue !== 'boolean') {
  206.                     inputValueValue = inputValue;
  207.                     if (typeof inputValue === 'object') {
  208.                         inputValueValue = JSON.stringify(inputValue, function (key, value) {
  209.                             if (typeof value === 'object' && value !== null) {
  210.                                 if (cache.indexOf(value) !== -1) {
  211.                                     // Circular reference found, discard key
  212.                                     return;
  213.                                 }
  214.                                 // Store value in our collection
  215.                                 cache.push(value);
  216.                             }
  217.                             return value;
  218.                         });
  219.                     }
  220.                     throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  221.                                     ' tokens, the input "' + inputValueValue +
  222.                                     '" is not a boolean, it is a ' +
  223.                                     typeof inputValue + '.  The expected value was "' +
  224.                                     referenceToken + '"');
  225.                 }
  226.                 if (inputValue !== referenceToken) {
  227.                     throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  228.                                     ' tokens, the input "' + inputValue + '" is not equal to "' +
  229.                                     referenceToken + '"');
  230.                 }
  231.             } else if (typeof referenceToken === 'number') {
  232.                 // If the input not a number, then throw an error.
  233.                 if (typeof inputValue !== 'number') {
  234.                     inputValueValue = inputValue;
  235.                     if (typeof inputValue === 'object') {
  236.                         inputValueValue = JSON.stringify(inputValue, function (key, value) {
  237.                             if (typeof value === 'object' && value !== null) {
  238.                                 if (cache.indexOf(value) !== -1) {
  239.                                     // Circular reference found, discard key
  240.                                     return;
  241.                                 }
  242.                                 // Store value in our collection
  243.                                 cache.push(value);
  244.                             }
  245.                             return value;
  246.                         });
  247.                     }
  248.                     throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  249.                                     ' tokens, the input "' + inputValueValue +
  250.                                     '" is not a number, it is a ' +
  251.                                     typeof inputValue + '.  The expected value was "' +
  252.                                     referenceToken + '"');
  253.                 }
  255.                 var difference = Math.abs(inputValue - referenceToken);
  256.                 if (isNaN(difference)) {
  257.                     throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  258.                                     ' tokens, the absolute value of the input "' +
  259.                                     inputValue + '" - the referenceToken "' +
  260.                                     referenceToken + '" is NaN?  It should be less than ' +
  261.                                     self.getParameter('tolerance'));
  262.                 }
  263.                 if (difference > self.getParameter('tolerance')) {
  264.                     throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  265.                                     ' tokens, the input "' + inputValue + '" is not within "' +
  266.                                     self.getParameter('tolerance') +
  267.                                     '" of the expected value "' +
  268.                                     referenceToken + '"');
  269.                 }
  270.             } else if (typeof referenceToken === 'string') {
  271.                 if (inputValue !== referenceToken) {
  272.                     // devices/test/auto/WatchEmulator.js needs this test for object because
  273.                     // if we receive a JSON object, then we should try to stringify it.
  274.                     if (typeof inputValue === 'object') {
  275.                         inputValueValue = null;
  276.                         try {
  277.                             inputValueValue = JSON.stringify(inputValue);
  278.                         } catch (err) {
  279.                             throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  280.                                             ' tokens, the input "' + inputValue + '" is !== ' +
  281.                                             ' to the expected value "' +
  282.                                             referenceToken + '".  The input was an object, and a string was expected.');
  283.                         }
  284.                         if (inputValueValue !== referenceToken) {
  285.                             throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  286.                                             ' tokens, the input "' + inputValueValue + '" is !== ' +
  287.                                             ' to the expected value "' +
  288.                                             referenceToken +
  289.                                             '".  The input was an object and JSON.stringify() did not throw an exception.' +
  290.                                             'A string was expected.');
  291.                         }
  292.                     }
  293.                 }
  294.             } else if (typeof referenceToken === 'object') {
  295.                 // Sadly, in JavaScript, objects that have the same
  296.                 // properties, but in a different order are not
  297.                 // consider equal in that Object.is() will return
  298.                 // false.  However, Ptolemy RecordTokens are by
  299.                 // default unordered (unless they are
  300.                 // OrderedRecordTokens), So, we have a function that
  301.                 // does a deep comparison and ignores differences in
  302.                 // property order.
  303.                 if (objectPropertiesEqual(inputValue, referenceToken)) {
  304.                     // The objects are not the same.
  306.                     // Generate string representations of the values
  307.                     // so that the user can possibly tell what went
  308.                     // wrong.
  309.                     cache = [];
  310.                     inputValueValue = JSON.stringify(inputValue, function (key, value) {
  311.                         if (typeof value === 'object' && value !== null) {
  312.                             if (cache.indexOf(value) !== -1) {
  313.                                 // Circular reference found, discard key
  314.                                 return;
  315.                             }
  316.                             // Store value in our collection
  317.                             cache.push(value);
  318.                         }
  319.                         return value;
  320.                     });
  321.                     cache = [];
  322.                     var referenceTokenValue = JSON.stringify(referenceToken, function (key, value) {
  323.                         if (typeof value === 'object' && value !== null) {
  324.                             if (cache.indexOf(value) !== -1) {
  325.                                 // Circular reference found, discard key
  326.                                 return;
  327.                             }
  328.                             // Store value in our collection
  329.                             cache.push(value);
  330.                         }
  331.                         return value;
  332.                     });
  334.                     cache = null; // Enable garbage collection
  336.                     // If we are comparing longs from CapeCode, then the values will be like "1L",
  337.                     // and stringify will return undefined.
  338.                     if (inputValueValue === undefined) {
  339.                         inputValueValue = inputValue;
  340.                     }
  341.                     if (referenceTokenValue === undefined) {
  342.                         referenceTokenValue = referenceToken;
  343.                     }
  345.                     if (inputValueValue !== referenceTokenValue) {
  346.                         // inputValueValue could still be undefined here if inputValue
  347.                         // was undefined.
  348.                         if (inputValueValue !== undefined && inputValueValue.length > 100) {
  349.                             inputValueValue = inputValueValue.substring(0, 100) + '...';
  350.                         }
  351.                         if (referenceTokenValue !== undefined && referenceTokenValue.length > 100) {
  352.                             referenceTokenValue = referenceTokenValue.substring(0, 100) + '...';
  353.                         }
  354.                         // Deal with referenceTokens with value 1L.
  355.                         if (typeof inputValueValue !== 'object' || typeof referenceTokenValue !== 'object' &&
  356.                             inputValueValue.toString() !== referenceTokenValue.toString) {
  357.                             throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  358.                                             ' tokens, the input Object \n"' + inputValueValue +
  359.                                             '" is !== to the expected value Object\n"' +
  360.                                             referenceTokenValue);
  361.                         }
  362.                     }
  363.                 }
  364.             } else {
  365.                 throw new Error(self.accessorName + ': After seeing ' + numberOfInputTokensSeen +
  366.                                 ' tokens, the referenceToken "' + referenceToken +
  367.                                 '" is not a number, it is a ' +
  368.                                 typeof referenceToken);
  369.             }
  370.             numberOfInputTokensSeen += 1;
  371.             // If we are past the end of the expected inputs, then read
  372.             if (numberOfInputTokensSeen >= correctValuesValues.length) {
  373.                 self.send('output', true);
  374.             } else {
  375.                 self.send('output', false);
  376.             }
  377.         } else {
  378.             self.send('output', true);
  379.         }
  380.     });
  381.     initialized = true;
  382. };
  384. /** If trainingMode is true, then updated the correctValues. */
  385. exports.wrapup = function () {
  386.     if (this.getParameter('trainingMode')) {
  387.         this.setParameter('correctValues', trainingTokens);
  388.     } else {
  389.         if (initialized) {
  390.             if (!inputHandled) {
  391.                 initialized = false;
  392.                 throw new Error(this.accessorName + ': The input handler of this accessor was never invoked. ' +
  393.                                 'Usually, this is an error indicating that ' +
  394.                                 'starvation is occurring.');
  395.             }
  396.             var correctValuesValues = this.getParameter('correctValues');
  397.             if (numberOfInputTokensSeen < correctValuesValues.length) {
  398.                 throw new Error(this.accessorName + ': The test produced only ' +
  399.                                 numberOfInputTokensSeen +
  400.                                 ' tokens, yet the correctValues parameter was ' +
  401.                                 'expecting ' +
  402.                                 correctValuesValues.length +
  403.                                 ' tokens');
  404.             }
  405.         }
  406.         initialized = false;
  407.     }
  408.     var name = this.accessorName;
  410.     // FIXME: Should we check to see if the name has no dots in and if
  411.     // it does not, add the container name?
  413.     //if (this.container) {
  414.     //    name = this.container.accessorName + "." + name;
  415.     //}
  417.     //
  418.     exports.wrappedUp = true;
  419.     // console.log("TrainableTest.js: wrapup() finished: " + name + ", exports.wrappedUp: " + exports.wrappedUp);
  421. };