Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/ai_detect/Flower_Classification_Tensorflow.js/train/node_modules/seedrandom/test/   drwxr-xr-x
Free 13.14 GB of 57.97 GB (22.67%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     nodetest.js (8.68 KB)      -rw-r--r--

var assert = require("assert");
var seedrandom = require("../seedrandom");
var requirejs = require("requirejs");

// Stub out requirejs if in the browser via browserify.
if (!requirejs.config) {
  requirejs = require;
} else {
  requirejs.config({
    baseUrl: __dirname
  });
}

describe("Nodejs API Test", function() {

it('should pass basic tests.', function() {
  var original = Math.random,
      result, r, xprng, obj, as2, as3, autoseed1, myrng,
      firstprng, secondprng, thirdprng, rng;

  result = Math.seedrandom('hello.');
  firstprng = Math.random;
  assert.ok(original !== firstprng, "Should change Math.random.");
  assert.equal(result, "hello.", "Should return short seed.");
  r = Math.random();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");
  r = Math.random();
  assert.equal(r, 0.3752569768646784, "Should be 'hello.'#2");

  // should be able to autoseed
  result = Math.seedrandom();
  secondprng = Math.random;
  assert.ok(original !== secondprng, "Should change Math.random.");
  assert.ok(firstprng !== secondprng, "Should change Math.random.");
  assert.equal(result.length, 256, "Should return short seed.");
  r = Math.random();
  assert.ok(r > 0, "Should be posititive.");
  assert.ok(r < 1, "Should be less than 1.");
  assert.ok(r != 0.9282578795792454, "Should not be 'hello.'#1");
  assert.ok(r != 0.3752569768646784, "Should not be 'hello.'#2");
  assert.ok(r != 0.7316977468919549, "Should not be 'hello.'#3");
  autoseed1 = r;

  // should be able to add entropy.
  result = Math.seedrandom('added entropy.', { entropy:true });
  assert.equal(result.length, 256, "Should return short seed.");
  thirdprng = Math.random;
  assert.ok(thirdprng !== secondprng, "Should change Math.random.");
  r = Math.random();
  assert.ok(r != 0.597067214994467, "Should not be 'added entropy.'#1");

  // Reset to original Math.random.
  Math.random = original;
  // should be able to use new Math.seedrandom('hello.')
  myrng = new Math.seedrandom('hello.');
  assert.ok(original === Math.random, "Should not change Math.random.");
  assert.ok(original !== myrng, "PRNG should not be Math.random.");
  r = myrng();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");

  // should be able to use seedrandom('hello.')"
  rng = seedrandom('hello.');
  assert.equal(typeof(rng), 'function', "Should return a function.");
  r = rng();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");
  assert.ok(original === Math.random, "Should not change Math.random.");
  assert.ok(original !== rng, "PRNG should not be Math.random.");

  // Global PRNG: set Math.random.
  // should be able to use seedrandom('hello.', { global: true })
  result = seedrandom('hello.', { global: true });
  assert.equal(result, 'hello.', "Should return short seed.");
  assert.ok(original != Math.random, "Should change Math.random.");
  r = Math.random();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");

  // Autoseeded non-global
  Math.random = original;
  // should be able to use seedrandom()
  result = seedrandom();
  assert.equal(typeof(result), 'function', "Should return function.");
  assert.ok(original === Math.random, "Should not change Math.random.");
  r = result();
  // got " + r);
  assert.ok(r != autoseed1, "Should not repeat previous autoseed.");
  assert.ok(r != 0.9282578795792454, "Should not be 'hello.'#1");
  assert.ok(r != 0.7316977468919549, "Should not be 'hello.'#3");

  // Mixing accumulated entropy.
  // should be able to use seedrandom('added entropy.', { entropy: true })
  rng = seedrandom('added entropy.', { entropy: true });
  r = result();
  // got " + r);
  assert.ok(r != autoseed1, "Should not repeat previous autoseed.");
  assert.ok(r != 0.597067214994467, "Should not be 'added entropy.'#1");

  // Legacy calling convention for mixing accumulated entropy.
  // should be able to use seedrandom('added entropy.', true)
  rng = seedrandom('added entropy.', true);
  r = result();
  // got " + r);
  assert.ok(r != autoseed1, "Should not repeat previous autoseed.");
  assert.ok(r != 0.597067214994467, "Should not be 'added entropy.'#1");

  // The pass option
  // should be able to use Math.seedrandom(null, { pass: ...
  obj = Math.seedrandom(null, { pass: function(prng, seed) {
    return { random: prng, seed: seed };
  }});
  assert.ok(original === Math.random, "Should not change Math.random.");
  assert.ok(original !== obj.random, "Should be different from Math.random.");
  assert.equal(typeof(obj.random), 'function', "Should return a PRNG function.");
  assert.equal(typeof(obj.seed), 'string', "Should return a seed.");
  as2 = obj.random();
  assert.ok(as2 != 0.9282578795792454, "Should not be 'hello.'#1");
  rng = seedrandom(obj.seed);
  as3 = rng();
  assert.equal(as2, as3, "Should be reproducible when using the seed.");

  // Exercise pass again, with explicit seed and global
  // should be able to use Math.seedrandom('hello.', { pass: ...
  result = Math.seedrandom('hello.', {
    global: 'abc',
    pass: function(prng, seed, global) {
      assert.equal(typeof(prng), 'function', "Callback arg #1 assert");
      assert.equal(seed, 'hello.', "Callback arg #2 assert");
      assert.equal(global, 'abc', "Callback arg #3 passed through.");
      assert.equal(prng(), 0.9282578795792454, "Should be 'hello.'#1");
      return 'def';
  }});
  assert.equal(result, 'def', "Should return value from callback.");
  assert.ok(original === Math.random, "Should not change Math.random.");

  // Legacy third argument callback argument:
  // should be able to use Math.seedrandom('hello.', { global: 50 }, callback)
  result = Math.seedrandom('hello.', { global: 50 },
    function(prng, seed, global) {
      assert.equal(typeof(prng), 'function', "Callback arg #1 assert");
      assert.equal(seed, 'hello.', "Callback arg #2 assert");
      assert.equal(global, 50, "Callback arg #3 assert");
      assert.equal(prng(), 0.9282578795792454, "Should be 'hello.'#1");
      return 'zzz';
  });
  assert.equal(result, 'zzz', "Should return value from callback.");
  assert.ok(original === Math.random, "Should not change Math.random.");

  // Global: false.
  // should be able to use new Math.seedrandom('hello.', {global: false})
  myrng = new Math.seedrandom('hello.', {global:false});
  assert.equal(typeof(myrng), 'function', "Should return a PRNG funciton.");
  assert.ok(original === Math.random, "Should not change Math.random.");
  assert.ok(original !== myrng, "PRNG should not be Math.random.");
  r = myrng();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");

  // options = {} when a method of Math.
  // should be able to use Math.seedrandom('hello.', {})
  result = Math.seedrandom('hello.');
  xprng = Math.random;
  assert.ok(original !== xprng, "Should change Math.random.");
  assert.equal(result, "hello.", "Should return short seed.");
  r = Math.random();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");
  r = Math.random();
  assert.equal(r, 0.3752569768646784, "Should be 'hello.'#2");
  Math.random = original;

  // options = {} when not a method of Math
  // should be able to use seedrandom('hello.', {})
  rng = seedrandom('hello.', {});
  assert.equal(typeof(rng), 'function', "Should return a function.");
  r = rng();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");
  assert.ok(original === Math.random, "Should not change Math.random.");
  assert.ok(original !== rng, "PRNG should not be Math.random.");
});

it('should support state api.', function() {
  // Verify that there is no state method
  var dummy = seedrandom('hello');
  var unexpected = -1;
  var expected = -1;
  try {
    unexpected = dummy.state();
  } catch(e) {
    expected = 1;
  }
  assert.equal(unexpected, -1);
  assert.equal(expected, 1);
  var count = 0;
  for (var x in dummy) {
    if (x == 'state') count += 1;
  }
  assert.equal(count, 0);

  // Verify that a state method can be added
  var saveable = seedrandom("secret-seed", {state: true});
  var ordinary = seedrandom("secret-seed");
  for (var j = 0; j < 1e2; ++j) {
    assert.equal(ordinary(), saveable());
  }
  var virgin = seedrandom("secret-seed");
  var saved = saveable.state();
  var replica = seedrandom("", {state: saved});
  for (var j = 0; j < 1e2; ++j) {
    var r = replica();
    assert.equal(r, saveable());
    assert.equal(r, ordinary());
    assert.ok(r != virgin());
  }
});

it('should support requirejs in node.', function() {
  var original = Math.random;
  var rsr = requirejs('../seedrandom');
  var rng = rsr('hello.');
  assert.equal(typeof(rng), 'function', "Should return a function.");
  var r = rng();
  assert.equal(r, 0.9282578795792454, "Should be 'hello.'#1");
  assert.ok(original === Math.random, "Should not change Math.random.");
  assert.ok(original !== rng, "PRNG should not be Math.random.");
});

// End of test.

});