Commit 712d664d: Removed duplicate code that is now available in RandomizedTesting.Generators

AsciiAlphanumGenerator.cs

-28

/src/Morfologik.TestFramework/RandomizedTesting/Generators/AsciiAlphanumGenerator.cs

View

//using System;

//using System.Collections.Generic;

//using System.Text;

//namespace Morfologik.TestFramework.RandomizedTesting.Generators

//{

// /// <summary>

// /// A generator emitting simple ASCII alphanumeric letters and numbers

// /// from the set (newlines not counted):

// /// <para/>

// /// abcdefghijklmnopqrstuvwxyz

// /// ABCDEFGHIJKLMNOPQRSTUVWXYZ

// /// 0123456789

// /// </summary>

// public class AsciiAlphanumGenerator : CodepointSetGenerator

// {

// private readonly static char[] CHARS =

// ("abcdefghijklmnopqrstuvwxyz" +

// "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +

// "0123456789").ToCharArray();

// public AsciiAlphanumGenerator()

// : base(CHARS)

// {

// }

//}

AsciiLettersGenerator.cs

-23

/src/Morfologik.TestFramework/RandomizedTesting/Generators/AsciiLettersGenerator.cs

View

namespace Morfologik.TestFramework.RandomizedTesting.Generators

{

/// <summary>

/// A generator emitting simple ASCII characters from the set

/// (newlines not counted):

/// <code>

/// abcdefghijklmnopqrstuvwxyz

/// ABCDEFGHIJKLMNOPQRSTUVWXYZ

/// </code>

/// </summary>

public class AsciiLettersGenerator : CodepointSetGenerator

{

private readonly static char[] Chars =

("abcdefghijklmnopqrstuvwxyz" +

"ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToCharArray();

public AsciiLettersGenerator()

: base(Chars)

{

}

CodepointSetGenerator.cs

-265

/src/Morfologik.TestFramework/RandomizedTesting/Generators/CodepointSetGenerator.cs

View

using J2N;

using System;

using System.Collections.Generic;

using System.Text;

namespace Morfologik.TestFramework.RandomizedTesting.Generators

{

/// <summary>

/// A string generator from a predefined set of codepoints or characters.

/// </summary>

public class CodepointSetGenerator //: StringGenerator

{

private readonly int[] bmp;

private readonly int[] supplementary;

private readonly int[] all;

/**

* All characters must be from BMP (no parts of surrogate pairs allowed).

*/

public CodepointSetGenerator(char[] chars)

{

this.bmp = new int[chars.Length];

this.supplementary = new int[0];

for (int i = 0; i < chars.Length; i++)

{

bmp[i] = ((int)chars[i]) & 0xffff;

if (IsSurrogate(chars[i]))

{

throw new ArgumentException("Value is part of a surrogate pair: 0x"

+ bmp[i].ToHexString());

}

this.all = Concat(bmp, supplementary);

if (all.Length == 0)

{

throw new ArgumentException("Empty set of characters?");

}

/**

* Parse the given {@link String} and split into BMP and supplementary codepoints.

*/

public CodepointSetGenerator(string s)

{

int bmps = 0;

int supplementaries = 0;

for (int i = 0; i < s.Length;)

{

int codepoint = s.CodePointAt(i);

if (/*Character.*/IsSupplementaryCodePoint(codepoint))

{

supplementaries++;

}

else

{

bmps++;

}

i += /*Character.*/CharCount(codepoint);

}

this.bmp = new int[bmps];

this.supplementary = new int[supplementaries];

for (int i = 0; i < s.Length;)

{

int codepoint = s.CodePointAt(i);

if (/*Character.*/IsSupplementaryCodePoint(codepoint))

{

supplementary[--supplementaries] = codepoint;

}

else

{

bmp[--bmps] = codepoint;

}

i += /*Character.*/CharCount(codepoint);

}

this.all = Concat(bmp, supplementary);

if (all.Length == 0)

{

throw new ArgumentException("Empty set of characters?");

}

public /*override*/ string OfCodeUnitsLength(System.Random r, int minCodeUnits, int maxCodeUnits)

{

int length = RandomNumbers.RandomInt32Between(r, minCodeUnits, maxCodeUnits);

// Check and cater for odd number of code units if no bmp characters are given.

if (bmp.Length == 0 && IsOdd(length))

{

if (minCodeUnits == maxCodeUnits)

{

throw new ArgumentException("Cannot return an odd number of code units "

+ " when surrogate pairs are the only available codepoints.");

}

else

{

// length is odd so we move forward or backward to the closest even number.

if (length == minCodeUnits)

{

length++;

}

else

{

length--;

}

//int[] codepoints = new int[length];

char[] chars = new char[length * 2];

int actual = 0;

while (length > 0)

{

int cp;

if (length == 1)

{

//codepoints[actual] = bmp[r.Next(bmp.Length)];

cp = bmp[r.Next(bmp.Length)];

}

else

{

//codepoints[actual] = all[r.Next(all.Length)];

cp = all[r.Next(all.Length)];

}

char[] temp = ToChars(cp);

for (int i = 0; i < temp.Length; i++)

chars[actual++] = temp[i];

//if (/*Character.*/IsSupplementaryCodePoint(codepoints[actual]))

if (/*Character.*/IsSupplementaryCodePoint(cp))

{

length -= 2;

}

else

{

length -= 1;

}

//actual++;

}

//return new string(codepoints, 0, actual);

return new string(chars, 0, actual);

}

//public override string OfCodePointsLength(System.Random r, int minCodePoints, int maxCodePoints)

//{

// int length = RandomNumbers.RandomInt32Between(r, minCodePoints, maxCodePoints);

// int[] codepoints = new int[length];

// while (length > 0)

// {

// codepoints[--length] = all[r.Next(all.Length)];

// }

// return new string(codepoints, 0, codepoints.Length);

//}

/** Is a given number odd? */

private static bool IsOdd(int v)

{

return (v & 1) != 0;

}

private int[] Concat(params int[][] arrays)

{

int totalLength = 0;

foreach (int[] a in arrays) totalLength += a.Length;

int[] concat = new int[totalLength];

for (int i = 0, j = 0; j < arrays.Length;)

{

System.Array.Copy(arrays[j], 0, concat, i, arrays[j].Length);

i += arrays[j].Length;

j++;

}

return concat;

}

private bool IsSurrogate(char chr)

{

return (chr >= 0xd800 && chr <= 0xdfff);

}

#region From Character Class

internal const int MaxCodePoint = 0x10FFFF;

internal const int MinCodePoint = 0x000000;

internal const int MinSupplementaryCodePoint = 0x010000;

internal const char MinLowSurrogate = '\uDC00';

internal const char MaxLowSurrogate = '\uDFFF';

internal const char MinHighSurrogate = '\uD800';

internal const char MaxHighSurrogate = '\uDBFF';

private static int CharCount(int codePoint)

{

// A given codepoint can be represented in .NET either by 1 char (up to UTF16),

// or by if it's a UTF32 codepoint, in which case the current char will be a surrogate

return codePoint >= MinSupplementaryCodePoint ? 2 : 1;

}

private static bool IsSupplementaryCodePoint(int codePoint)

{

return (MinSupplementaryCodePoint <= codePoint && MaxCodePoint >= codePoint);

}

private static bool IsValidCodePoint(int codePoint)

{

return (MinCodePoint <= codePoint && MaxCodePoint >= codePoint);

}

private static char[] ToChars(int codePoint)

{

if (!IsValidCodePoint(codePoint))

{

throw new ArgumentException();

}

if (IsSupplementaryCodePoint(codePoint))

{

int cpPrime = codePoint - 0x10000;

int high = 0xD800 | ((cpPrime >> 10) & 0x3FF);

int low = 0xDC00 | (cpPrime & 0x3FF);

return new char[] { (char)high, (char)low };

}

return new char[] { (char)codePoint };

}

#endregion

}

internal static class ExtensionMethods

{

public static int CodePointAt(this string seq, int index)

{

char c1 = seq[index++];

if (char.IsHighSurrogate(c1))

{

if (index < seq.Length)

{

char c2 = seq[index];

if (char.IsLowSurrogate(c2))

{

return ToCodePoint(c1, c2);

}

return c1;

}

public static int ToCodePoint(char high, char low)

{

// Optimized form of:

// return ((high - MIN_HIGH_SURROGATE) << 10)

// + (low - MIN_LOW_SURROGATE)

// + MIN_SUPPLEMENTARY_CODE_POINT;

return ((high << 10) + low) + (CodepointSetGenerator.MinSupplementaryCodePoint

- (CodepointSetGenerator.MinHighSurrogate << 10)

- CodepointSetGenerator.MinLowSurrogate);

}

RandomNumbers.cs

-121

/src/Morfologik.TestFramework/RandomizedTesting/Generators/RandomNumbers.cs

View

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Text;

namespace Morfologik.TestFramework.RandomizedTesting.Generators

{

/// <summary>

/// Utility classes for selecting random numbers from within a range or the

/// numeric domain for a given type.

/// </summary>

/// <seealso cref="BiasedNumbers"/>

public static class RandomNumbers

{

/// <summary>

/// A random integer from <paramref name="min"/> to <paramref name="max"/> (inclusive).

/// </summary>

public static int RandomInt32Between(Random random, int min, int max)

{

Debug.Assert(min <= max, String.Format("Min must be less than or equal max int. min: {0}, max: {1}", min, max));

var range = max - min;

if (range < Int32.MaxValue)

return min + random.Next(1 + range);

return min + (int)Math.Round(random.NextDouble() * range);

}

/* .NET has random.Next(max) which negates the need for randomInt(Random random, int max) as */

// /**

//* A random integer between <code>min</code> (inclusive) and <code>max</code> (inclusive).

//*/

// public static int RandomIntBetween(Random r, int min, int max)

// {

// Debug.Assert(max >= min, "max must be >= min: " + min + ", " + max);

// long range = (long)max - (long)min;

// if (range < int.MaxValue)

// {

// return min + r.Next(1 + (int)range);

// }

// else

// {

// return ToIntExact(min + NextLong(r, 1 + range));

// }

// /**

// * A random long between <code>min</code> (inclusive) and <code>max</code> (inclusive).

// */

// public static long TandomLongBetween(Random r, long min, long max)

// {

// Debug.Assert(max >= min , "max must be >= min: " + min + ", " + max);

// long range = max - min;

// if (range < 0)

// {

// range -= long.MaxValue;

// if (range == long.MinValue)

// {

// // Full spectrum.

// return r.NextInt64();

// }

// else

// {

// long first = r.NextInt64() & long.MaxValue;

// long second = range == long.MaxValue ? (r.NextInt64() & long.MaxValue) : NextLong(r, range + 1);

// return min + first + second;

// }

// else

// {

// long second = range == long.MaxValue ? (r.NextInt64() & long.MaxValue) : NextLong(r, range + 1);

// return min + second;

// }

// /**

// * Similar to {@link Random#nextInt(int)}, but returns a long between

// * 0 (inclusive) and <code>n</code> (exclusive).

// *

// * @param rnd Random generator.

// * @param n the bound on the random number to be returned. Must be

// * positive.

// * @return Returns a random number between 0 and n-1.

// */

// public static long NextLong(Random rnd, long n)

// {

// if (n <= 0)

// {

// throw new ArgumentException("n <= 0: " + n);

// }

// long value = rnd.NextInt64();

// long range = n - 1;

// if ((n & range) == 0L)

// {

// value &= range;

// }

// else

// {

// for (long u = value.TripleShift(1); u + range - (value = u % n) < 0L;)

// {

// u = rnd.NextInt64().TripleShift(1);

// }

// return value;

// }

// private static int ToIntExact(long value)

// {

// if (value > int.MaxValue)

// {

// throw new ArithmeticException("Overflow: " + value);

// }

// else

// {

// return (int)value;

// }

}

Morfologik.TestFramework.csproj

+1

/src/Morfologik.TestFramework/Morfologik.TestFramework.csproj

View

</ItemGroup>

</Project>

TestCase.cs

-1+1

/src/Morfologik.TestFramework/TestCase.cs

View

using Morfologik.TestFramework.RandomizedTesting.Generators;

using NUnit.Framework;

using RandomizedTesting.Generators;

using System;

using System.Collections;

using System.Collections.Generic;



	src/Morfologik.TestFramework
	RandomizedTesting/Generators
	AsciiAlphanumGenerator.cs
	AsciiLettersGenerator.cs
	CodepointSetGenerator.cs
	RandomNumbers.cs
	Morfologik.TestFramework.csproj
	TestCase.cs