Java Code Examples for java.util.Random#nextLong()

/**
 * Create's a new Simplex-Noise instance, that can be used for pseudorandom number-generation.
 * 
 * @param seed The seed for this SimplexNoise generator. (Cannot be changed)
 **/
public SimplexNoise(long seed)
{
	
	// Shuffle array by using random number generator made from the given seed.
	Random rnd = new Random(seed);
	for(int r = this.p.length; r > 1; r--)
	{
		swap(this.p, r - 1, rnd.nextInt(r));
	}
	
	// Copy Permutations
	for(int i = 0; i < 512; i++)
	{
		this.perm[i] = this.p[i & 255];
		this.permMod12[i] = (short) (this.perm[i] % 12);
	}
	
	octaveDepthPositionPermutationTable = new double[64];
	for(int i = 0; i < octaveDepthPositionPermutationTable.length; i++)
	{
		octaveDepthPositionPermutationTable[i] = rnd.nextFloat() * (int) (rnd.nextLong() & 0xFFFFFFFF);
	}
	
}
 

/**
 * test get find token from stream
 * @throws java.io.IOException if an IO exception happens during deserialization
 */
@Test
public void getFindTokenTest() throws IOException {
  short version = 0;
  Random random = new Random();
  long latestBlobUpdateTime = random.nextLong();
  long bytesRead = random.nextLong();
  Set<String> lastReadBlobIds = new HashSet<>();
  lastReadBlobIds.add("blobid1");
  lastReadBlobIds.add("blobid2");

  CosmosUpdateTimeFindToken cosmosUpdateTimeFindToken1 =
      new CosmosUpdateTimeFindToken(version, latestBlobUpdateTime, bytesRead, lastReadBlobIds);
  DataInputStream stream = new DataInputStream(new ByteArrayInputStream(cosmosUpdateTimeFindToken1.toBytes()));
  CosmosUpdateTimeFindToken cosmosUpdateTimeFindToken2 =
      (CosmosUpdateTimeFindToken) new CosmosUpdateTimeFindTokenFactory().getFindToken(stream);
  assertEquals("incorrect token returned from factory", cosmosUpdateTimeFindToken1, cosmosUpdateTimeFindToken2);
}
 

public RMF_Motor(Context context, Long id, String name, long seed, Long roomId) {
    super(context, id, name, BRAND, MODEL, Type.AUTOPAIR, roomId);
    buttons.add(new UpButton(context, id));
    buttons.add(new StopButton(context, id));
    buttons.add(new DownButton(context, id));
    if (seed == -1) {
        // init seed for this receiver instance, to always generate the same codes from now on
        Random ran = new Random();
        this.seed = ran.nextLong();
    } else {
        this.seed = seed;
    }
}
 

private long findNewFreeOrRemoved() {
    long free = KolobokeLongIntHashMap.this.freeValue;
    Random random = ThreadLocalRandom.current();
    long newFree;
    {
        do {
            newFree = ((long) (random.nextLong()));
        } while ((newFree == free) || ((index(newFree)) >= 0) );
    }
    return newFree;
}
 

public Unitec_EIM_209_48110(Context context, Long id, String name, long seed, Long roomId) {
    super(context, id, name, BRAND, MODEL, Type.AUTOPAIR, roomId);

    buttons.add(new OnButton(context, id));
    buttons.add(new OffButton(context, id));

    if (seed == -1) {
        // init seed for this receiver instance, to always generate the same codes from now on
        Random ran = new Random();
        this.seed = ran.nextLong();
    } else {
        this.seed = seed;
    }
}
 

@Test
public void testSplitMerge63() {
	Random rnd = new Random();
	for (int i = 0; i < 1000; i++) {
		long[] l = new long[]{rnd.nextLong()>>>1, rnd.nextLong()>>>1};
		int[] x = BitTools.merge(63, l);
		long[] l2 = BitTools.split(2, 63, x); 
		assertArrayEquals(l, l2);
	}
}
 

/**
 * Gets a long number between two values
 * 
 * @param rnd
 * @param range
 * 
 * @return long
 */
static long betweenPositive(Random rnd, Range<Long> range) {
  if (range.getLower().equals(range.getUpper())) {
    return range.getLower();
  }
  long nextRnd = rnd.nextLong();
  long normRange = (range.getUpper() - range.getLower() + 1);
  return Math.abs(nextRnd % normRange) + range.getLower();
}
 

@Test
public void testLongStream() {
    final long seed = System.currentTimeMillis();
    final Random r1 = new Random(seed);
    final long[] a = new long[SIZE];
    for (int i=0; i < SIZE; i++) {
        a[i] = r1.nextLong();
    }

    final Random r2 = new Random(seed); // same seed
    final long[] b = r2.longs().limit(SIZE).toArray();
    assertEquals(a, b);
}
 

public BaseImpl() {
    values = new long[N];
    final Random random = new Random(657483918);
    for (int i = 0; i < N; i++) {
        values[i] = random.nextLong();
    }
}
 

@Test
public void subtractionVersusAdditionWithRandomAddresses()
{
    final Random random = new Random();
    final int randomInt = random.nextInt();
    final IPv6Address randomAddress = new IPv6Address(random.nextLong(), random.nextLong());
    assertEquals(randomAddress, randomAddress.add(randomInt).subtract(randomInt));
}
 

@Override
protected LongValue[] getTestData() {
	Random rnd = new Random(874597969123412341L);
	long rndLong = rnd.nextLong();
	
	return new LongValue[] {new LongValue(0L), new LongValue(1L), new LongValue(-1L),
						new LongValue(Long.MAX_VALUE), new LongValue(Long.MIN_VALUE),
						new LongValue(rndLong), new LongValue(-rndLong)};
}
 

@Test
public void testAbortProcedureFail() throws Exception {
  Random randomGenerator = new Random();
  long procId = randomGenerator.nextLong();

  boolean abortResult = ADMIN.abortProcedure(procId, true);
  assertFalse(abortResult);
}
 

public static SimpleAllPrimitiveCreator newRandom() {
  final Random r = new Random();
  return new AutoValue_SimpleAllPrimitiveCreator(
      0L,
      r.nextBoolean(),
      (byte) r.nextInt(),
      (short) r.nextInt(),
      r.nextInt(),
      r.nextLong(),
      r.nextFloat(),
      r.nextDouble()
  );
}
 

public ClientUserAuths(int clientProxyHashcode)
{
  m_seed = clientProxyHashcode;
  uniqueIdGenerator = new Random(m_seed + System.currentTimeMillis());
  m_firstId = uniqueIdGenerator.nextLong();
}
 

/**
 * Test we can invoke an SPL operator with various parameter types.
 */

private void testOpParams(String testName, OpParamAdder opParamAdder) throws Exception {
    
    Topology topology = new Topology(testName); 
    opParamAdder.init(topology, getConfig());
    
    StreamSchema schema = Type.Factory.getStreamSchema(
            "tuple<"
            + "rstring r"
            + ", ustring u"
            + ", boolean b"
            + ", int8 i8, int16 i16, int32 i32, int64 i64"
            + ", uint8 ui8, uint16 ui16, uint32 ui32, uint64 ui64"
            + ", float32 f32, float64 f64"
            + " >");
    
    Map<String,Object> expectedValues = new HashMap<>();
    
    Random rand = new Random();
    String r = "test    X\tY\"Lit\nerals\\nX\\tY " + rand.nextInt();
    opParamAdder.put("r", r);
    String u = "test    X\tY\"Lit\nerals\\nX\\tY " + rand.nextInt();
    opParamAdder.put("u", SPL.createValue(u, MetaType.USTRING));
    
    expectedValues.put("r", new RString(r));
    expectedValues.put("u", u);

    boolean b = rand.nextBoolean();
    opParamAdder.put("b", b);
    expectedValues.put("b", b);
    
    byte i8 = (byte) rand.nextInt();
    short i16 = (short) rand.nextInt(); 
    int i32 = rand.nextInt();
    long i64 = rand.nextLong(); 
    opParamAdder.put("i8", i8);
    opParamAdder.put("i16", i16); 
    opParamAdder.put("i32", i32); 
    opParamAdder.put("i64", i64); 
    
    expectedValues.put("i8", i8);
    expectedValues.put("i16", i16); 
    expectedValues.put("i32", i32); 
    expectedValues.put("i64", i64); 

    byte ui8 = (byte) 0xFF;       // 255 => -1
    short ui16 = (short) 0xFFFE;  // 65534 => -2 
    int ui32 = 0xFFFFFFFD;        // 4294967293 => -3
    long ui64 = 0xFFFFFFFFFFFFFFFCL; // 18446744073709551612 => -4
    opParamAdder.put("ui8", SPL.createValue(ui8, MetaType.UINT8));
    opParamAdder.put("ui16", SPL.createValue(ui16, MetaType.UINT16));
    opParamAdder.put("ui32", SPL.createValue(ui32, MetaType.UINT32)); 
    opParamAdder.put("ui64", SPL.createValue(ui64, MetaType.UINT64)); 
    
    expectedValues.put("ui8", ui8);
    expectedValues.put("ui16", ui16);
    expectedValues.put("ui32", ui32);
    expectedValues.put("ui64", ui64);
    
    float f32 = 4.0f;
    double f64 = 32.0;
    opParamAdder.put("f32", f32); 
    opParamAdder.put("f64", f64);
    expectedValues.put("f32", f32); 
    expectedValues.put("f64", f64);
   
    SPL.addToolkit(topology, new File(getTestRoot(), "spl/testtk"));
    SPLStream paramTuple = SPL.invokeSource(topology, "testgen::TypeLiteralTester", opParamAdder.getParams(), schema);
    
    Tuple expectedTuple = schema.getTuple(expectedValues);
    
    Tester tester = topology.getTester();
    
    Condition<Long> expectedCount = tester.tupleCount(paramTuple, 1);
    Condition<?> contents = tester.tupleContents(paramTuple, expectedTuple);;
    complete(tester, expectedCount.and(contents), 10, TimeUnit.SECONDS);
    
    assertTrue(contents.valid());
    assertTrue(expectedCount.valid());
}
 

@Test
public void testTuple5CustomObjects() {
	Random rnd = new Random(807346528946L);
	
	SimpleTypes a = new SimpleTypes();
	SimpleTypes b = new SimpleTypes(rnd.nextInt(), rnd.nextLong(), (byte) rnd.nextInt(),
			StringUtils.getRandomString(rnd, 10, 100), (short) rnd.nextInt(), rnd.nextDouble());
	SimpleTypes c = new SimpleTypes(rnd.nextInt(), rnd.nextLong(), (byte) rnd.nextInt(),
			StringUtils.getRandomString(rnd, 10, 100), (short) rnd.nextInt(), rnd.nextDouble());
	SimpleTypes d = new SimpleTypes(rnd.nextInt(), rnd.nextLong(), (byte) rnd.nextInt(),
			StringUtils.getRandomString(rnd, 10, 100), (short) rnd.nextInt(), rnd.nextDouble());
	SimpleTypes e = new SimpleTypes(rnd.nextInt(), rnd.nextLong(), (byte) rnd.nextInt(),
			StringUtils.getRandomString(rnd, 10, 100), (short) rnd.nextInt(), rnd.nextDouble());
	SimpleTypes f = new SimpleTypes(rnd.nextInt(), rnd.nextLong(), (byte) rnd.nextInt(),
			StringUtils.getRandomString(rnd, 10, 100), (short) rnd.nextInt(), rnd.nextDouble());
	SimpleTypes g = new SimpleTypes(rnd.nextInt(), rnd.nextLong(), (byte) rnd.nextInt(),
			StringUtils.getRandomString(rnd, 10, 100), (short) rnd.nextInt(), rnd.nextDouble());
	
	ComplexNestedObject1 o1 = new ComplexNestedObject1(5626435);
	ComplexNestedObject1 o2 = new ComplexNestedObject1(76923);
	ComplexNestedObject1 o3 = new ComplexNestedObject1(-1100);
	ComplexNestedObject1 o4 = new ComplexNestedObject1(0);
	ComplexNestedObject1 o5 = new ComplexNestedObject1(44);
	
	ComplexNestedObject2 co1 = new ComplexNestedObject2(rnd);
	ComplexNestedObject2 co2 = new ComplexNestedObject2();
	ComplexNestedObject2 co3 = new ComplexNestedObject2(rnd);
	ComplexNestedObject2 co4 = new ComplexNestedObject2(rnd);
	
	Book b1 = new Book(976243875L, "The Serialization Odysse", 42);
	Book b2 = new Book(0L, "Debugging byte streams", 1337);
	Book b3 = new Book(-1L, "Low level interfaces", 0xC0FFEE);
	Book b4 = new Book(Long.MAX_VALUE, "The joy of bits and bytes", 0xDEADBEEF);
	Book b5 = new Book(Long.MIN_VALUE, "Winnign a prize for creative test strings", 0xBADF00);
	Book b6 = new Book(-2L, "Distributed Systems", 0xABCDEF0123456789L);
	
	ArrayList<String> list = new ArrayList<String>();
	list.add("A");
	list.add("B");
	list.add("C");
	list.add("D");
	list.add("E");
	
	BookAuthor ba1 = new BookAuthor(976243875L, list, "Arno Nym");
	
	ArrayList<String> list2 = new ArrayList<String>();
	BookAuthor ba2 = new BookAuthor(987654321L, list2, "The Saurus");
	
	
	@SuppressWarnings("unchecked")
	Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>[] testTuples = new Tuple5[] {
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(a, b1, o1, ba1, co1),
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(b, b2, o2, ba2, co2),
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(c, b3, o3, ba1, co3),
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(d, b2, o4, ba1, co4),
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(e, b4, o5, ba2, co4),
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(f, b5, o1, ba2, co4),
			new Tuple5<SimpleTypes, Book, ComplexNestedObject1, BookAuthor, ComplexNestedObject2>(g, b6, o4, ba1, co2)
	};
	
	runTests(-1, testTuples);
}
 

@Test
public void testCheckpointing() throws Exception {
	source.autoAck = false;

	StreamSource<String, RMQSource<String>> src = new StreamSource<>(source);
	AbstractStreamOperatorTestHarness<String> testHarness =
		new AbstractStreamOperatorTestHarness<>(src, 1, 1, 0);
	testHarness.open();

	sourceThread.start();

	Thread.sleep(5);

	final Random random = new Random(System.currentTimeMillis());
	int numSnapshots = 50;
	long previousSnapshotId;
	long lastSnapshotId = 0;

	long totalNumberOfAcks = 0;

	for (int i = 0; i < numSnapshots; i++) {
		long snapshotId = random.nextLong();
		OperatorSubtaskState data;

		synchronized (DummySourceContext.lock) {
			data = testHarness.snapshot(snapshotId, System.currentTimeMillis());
			previousSnapshotId = lastSnapshotId;
			lastSnapshotId = messageId;
		}
		// let some time pass
		Thread.sleep(5);

		// check if the correct number of messages have been snapshotted
		final long numIds = lastSnapshotId - previousSnapshotId;

		RMQTestSource sourceCopy = new RMQTestSource();
		StreamSource<String, RMQTestSource> srcCopy = new StreamSource<>(sourceCopy);
		AbstractStreamOperatorTestHarness<String> testHarnessCopy =
			new AbstractStreamOperatorTestHarness<>(srcCopy, 1, 1, 0);

		testHarnessCopy.setup();
		testHarnessCopy.initializeState(data);
		testHarnessCopy.open();

		ArrayDeque<Tuple2<Long, Set<String>>> deque = sourceCopy.getRestoredState();
		Set<String> messageIds = deque.getLast().f1;

		assertEquals(numIds, messageIds.size());
		if (messageIds.size() > 0) {
			assertTrue(messageIds.contains(Long.toString(lastSnapshotId)));
		}

		// check if the messages are being acknowledged and the transaction committed
		synchronized (DummySourceContext.lock) {
			source.notifyCheckpointComplete(snapshotId);
		}
		totalNumberOfAcks += numIds;

	}

	Mockito.verify(source.channel, Mockito.times((int) totalNumberOfAcks)).basicAck(Mockito.anyLong(), Mockito.eq(false));
	Mockito.verify(source.channel, Mockito.times(numSnapshots)).txCommit();

}
 

@Test( timeout = 10000)
@SuppressWarnings("unchecked") // mocked generics
public void testLocalizerRunnerException() throws Exception {
  DrainDispatcher dispatcher = new DrainDispatcher();
  dispatcher.init(conf);
  dispatcher.start();
  EventHandler<ApplicationEvent> applicationBus = mock(EventHandler.class);
  dispatcher.register(ApplicationEventType.class, applicationBus);
  EventHandler<ContainerEvent> containerBus = mock(EventHandler.class);
  dispatcher.register(ContainerEventType.class, containerBus);

  ContainerExecutor exec = mock(ContainerExecutor.class);
  LocalDirsHandlerService dirsHandler = new LocalDirsHandlerService();
  LocalDirsHandlerService dirsHandlerSpy = spy(dirsHandler);
  dirsHandlerSpy.init(conf);

  DeletionService delServiceReal = new DeletionService(exec);
  DeletionService delService = spy(delServiceReal);
  delService.init(new Configuration());
  delService.start();

  ResourceLocalizationService rawService =
      new ResourceLocalizationService(dispatcher, exec, delService,
      dirsHandlerSpy, nmContext);
  ResourceLocalizationService spyService = spy(rawService);
  doReturn(mockServer).when(spyService).createServer();
  try {
    spyService.init(conf);
    spyService.start();

    // init application
    final Application app = mock(Application.class);
    final ApplicationId appId =
        BuilderUtils.newApplicationId(314159265358979L, 3);
    when(app.getUser()).thenReturn("user0");
    when(app.getAppId()).thenReturn(appId);
    spyService.handle(new ApplicationLocalizationEvent(
        LocalizationEventType.INIT_APPLICATION_RESOURCES, app));
    dispatcher.await();

    Random r = new Random();
    long seed = r.nextLong();
    System.out.println("SEED: " + seed);
    r.setSeed(seed);
    final Container c = getMockContainer(appId, 42, "user0");
    final LocalResource resource1 = getPrivateMockedResource(r);
    System.out.println("Here 4");
    
    final LocalResourceRequest req1 = new LocalResourceRequest(resource1);
    Map<LocalResourceVisibility, Collection<LocalResourceRequest>> rsrcs =
      new HashMap<LocalResourceVisibility, 
                  Collection<LocalResourceRequest>>();
    List<LocalResourceRequest> privateResourceList =
        new ArrayList<LocalResourceRequest>();
    privateResourceList.add(req1);
    rsrcs.put(LocalResourceVisibility.PRIVATE, privateResourceList);

    final Constructor<?>[] constructors =
        FSError.class.getDeclaredConstructors();
    constructors[0].setAccessible(true);
    FSError fsError =
        (FSError) constructors[0].newInstance(new IOException("Disk Error"));

    Mockito
      .doThrow(fsError)
      .when(dirsHandlerSpy)
      .getLocalPathForWrite(isA(String.class));
    spyService.handle(new ContainerLocalizationRequestEvent(c, rsrcs));
    Thread.sleep(1000);
    dispatcher.await();
    // Verify if ContainerResourceFailedEvent is invoked on FSError
    verify(containerBus).handle(isA(ContainerResourceFailedEvent.class));
  } finally {
    spyService.stop();
    dispatcher.stop();
    delService.stop();
  }
}
 

public void testBinary() throws IOException {
  JobConf job = new JobConf();
  FileSystem fs = FileSystem.getLocal(job);
  Path dir = new Path(System.getProperty("test.build.data",".") + "/mapred");
  Path file = new Path(dir, "testbinary.seq");
  Random r = new Random();
  long seed = r.nextLong();
  r.setSeed(seed);

  fs.delete(dir, true);
  FileInputFormat.setInputPaths(job, dir);

  Text tkey = new Text();
  Text tval = new Text();

  SequenceFile.Writer writer =
    new SequenceFile.Writer(fs, job, file, Text.class, Text.class);
  try {
    for (int i = 0; i < RECORDS; ++i) {
      tkey.set(Integer.toString(r.nextInt(), 36));
      tval.set(Long.toString(r.nextLong(), 36));
      writer.append(tkey, tval);
    }
  } finally {
    writer.close();
  }

  InputFormat<BytesWritable,BytesWritable> bformat =
    new SequenceFileAsBinaryInputFormat();

  int count = 0;
  r.setSeed(seed);
  BytesWritable bkey = new BytesWritable();
  BytesWritable bval = new BytesWritable();
  Text cmpkey = new Text();
  Text cmpval = new Text();
  DataInputBuffer buf = new DataInputBuffer();
  final int NUM_SPLITS = 3;
  FileInputFormat.setInputPaths(job, file);
  for (InputSplit split : bformat.getSplits(job, NUM_SPLITS)) {
    RecordReader<BytesWritable,BytesWritable> reader =
      bformat.getRecordReader(split, job, Reporter.NULL);
    try {
      while (reader.next(bkey, bval)) {
        tkey.set(Integer.toString(r.nextInt(), 36));
        tval.set(Long.toString(r.nextLong(), 36));
        buf.reset(bkey.getBytes(), bkey.getLength());
        cmpkey.readFields(buf);
        buf.reset(bval.getBytes(), bval.getLength());
        cmpval.readFields(buf);
        assertTrue(
            "Keys don't match: " + "*" + cmpkey.toString() + ":" +
                                         tkey.toString() + "*",
            cmpkey.toString().equals(tkey.toString()));
        assertTrue(
            "Vals don't match: " + "*" + cmpval.toString() + ":" +
                                         tval.toString() + "*",
            cmpval.toString().equals(tval.toString()));
        ++count;
      }
    } finally {
      reader.close();
    }
  }
  assertEquals("Some records not found", RECORDS, count);
}
 

/**
 * Generate a new device identity using a provided random number generator
 * class. This is used for testing.
 *
 * @param rng random number generator to retrieve the next long from
 * @return verifier device identity based on the input from the provided
 *         random number generator
 */
@VisibleForTesting
static VerifierDeviceIdentity generate(Random rng) {
    long identity = rng.nextLong();
    return new VerifierDeviceIdentity(identity);
}