package com.linkedin.databus.core.util;
/*
*
* Copyright 2013 LinkedIn Corp. All rights reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.Random;
import com.linkedin.databus.core.DbusEvent;
import com.linkedin.databus.core.DbusEventFactory;
import com.linkedin.databus.core.DbusEventV1Factory;
import com.linkedin.databus.core.DbusEventInfo;
import com.linkedin.databus.core.DbusEventInternalReadable;
import com.linkedin.databus.core.DbusEventKey;
import com.linkedin.databus.core.DbusOpcode;
import com.linkedin.databus.core.KeyTypeNotImplementedException;
public class RngUtils {
public static final String Letters ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
public static final String Digits = "0123456789";
public static final String LettersAndDigits = Letters + Digits;
/* A consistent random number generator to make tests repeatable */
public static final Random seededRandom = new Random(192348092834L);
public static final Random random = new Random();
public static final DbusEventFactory _eventFactory = new DbusEventV1Factory();
public static final byte[] schemaMd5 = "abcdefghijklmnop".getBytes(Charset.defaultCharset());
public static String randomString(int length) {
return randomString(seededRandom, length);
}
public static String randomString(Random rng, int length) {
StringBuilder sb = new StringBuilder();
for (int i=0; i < length;++i) {
sb.append(LettersAndDigits.charAt(rng.nextInt(LettersAndDigits.length())));
}
return sb.toString();
}
public static long randomLong() {
return seededRandom.nextLong();
}
public static long randomPositiveLong() {
return randomPositiveLong(seededRandom);
}
public static long randomPositiveLong(Random rng) {
long randomLong = rng.nextLong();
return Long.MIN_VALUE == randomLong ? Long.MAX_VALUE : Math.abs(randomLong);
}
/**
*
* @param keyMin
* @param keyMax
* @return random long number in range [keyMin, keyMax)
* Equivalent to [keyMin, keyMax-1]
*/
public static long randomPositiveLong(long keyMin, long keyMax)
{
return randomPositiveLong(seededRandom, keyMin, keyMax);
}
public static long randomPositiveLong(Random rng, long keyMin, long keyMax)
{
long randomLongOffset = Math.abs(rng.nextLong() % (keyMax-keyMin));
return (keyMin + randomLongOffset);
}
public static short randomPositiveShort() {
return randomPositiveShort(seededRandom);
}
public static short randomPositiveShort(Random rng) {
short randomShort = (short) (rng.nextInt() & 0x7f);
return randomShort;
}
public static DbusEvent randomEvent(short srcId)
{
ByteBuffer serBuf = ByteBuffer.allocate(1000).order(_eventFactory.getByteOrder());
try
{
DbusEventInfo eventInfo = new DbusEventInfo(DbusOpcode.UPSERT,
0L, // Sequence number
(short) 0, // physical Partition
randomPositiveShort(),
System.currentTimeMillis(),
srcId,
schemaMd5,
randomString(20).getBytes(Charset.defaultCharset()),
randomPositiveShort() % 100 <= 1,
false /* autoCommit */);
eventInfo.setEventSerializationVersion(DbusEventFactory.DBUS_EVENT_V1); // make this explicit
DbusEventFactory.serializeEvent(new DbusEventKey(randomLong()), serBuf, eventInfo);
}
catch (KeyTypeNotImplementedException e1)
{
throw new RuntimeException(e1);
}
serBuf.rewind();
DbusEventInternalReadable e = _eventFactory.createReadOnlyDbusEventFromBuffer(serBuf, serBuf.position());
return e;
}
public static int randomPositiveInt() {
return randomPositiveInt(seededRandom);
}
public static int randomPositiveInt(Random rng) {
int i = rng.nextInt();
int randomInt = (i == Integer.MIN_VALUE) ? Integer.MAX_VALUE : Math.abs(i);
return randomInt;
}
public static long randomGaussianLong(long min, long max, Random rng)
{
long v = (long)((max + min) * 0.5 + rng.nextGaussian() * (max - min) * 0.5);
return v < min ? min : (v > max ? max : v);
}
}