public void Setup()
{
// SetUp 意味着整个测试过程，对于每一个 Test 本方法都要执行一次。
// 默认使用初始序列号.
sequence = new MySequence();
}
static void Main(string[] args)
{
// 构造初始的序列号. 001
MySequence sequence = new MySequence();
Console.WriteLine(sequence);
// 序列号: N99
MySequence n99 = new MySequence("N99");
// 序列号: P00
MySequence p00 = new MySequence("P00");
// 序列号 递增
n99++;
if (n99 == p00)
{
Console.WriteLine(n99);
}
// 序列号 递减
p00--;
if (n99 != p00)
{
Console.WriteLine(p00);
}
// 执行 n99 = n99 + 111.
n99 += 111;
Console.WriteLine(n99);
Console.ReadLine();
}
/// <summary>
/// 重载 Equals 方法.
/// </summary>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj is MySequence)
{
MySequence oSequence = obj as MySequence;
return(oSequence.highValue == this.highValue && oSequence.lowValue == this.lowValue);
}
return(false);
}
public void TestFixtureSetUp()
{
// TestFixtureSetUp 意味着整个测试过程，本方法只执行一次.
// 初始化最小序列号
minSequenct = new MySequence('0', 1);
// 初始化最大序列号
maxSequenct = new MySequence('Z', 99);
}
/// <summary>
/// 重载运算符 +
/// </summary>
/// <param name="val"></param>
/// <param name="step"></param>
/// <returns></returns>
public static MySequence operator +(MySequence val, int step)
{
MySequence result = new MySequence(val.highValue, val.lowValue);
// 低位++
result.lowValue += step;
if (result.lowValue >= 100)
{
// 如果低位超出范围
// 高位 +
result.highValue += result.lowValue / 100;
// 低位取余
result.lowValue = result.lowValue % 100;
if (result.highValue >= HighCharArray.Length)
{
// 如果 高位大于 可用字符数组大小，溢出.
throw new OverflowException();
}
}
return(result);
}
/// <summary>
/// 重载运算符 +
/// </summary>
/// <param name="val"></param>
/// <param name="step"></param>
/// <returns></returns>
public static MySequence operator +(MySequence val, int step)
{
MySequence result = new MySequence(val.highValue, val.lowValue);
// 低位++
result.lowValue += step;
if (result.lowValue >= 100)
{
// 如果低位超出范围
// 高位 +
result.highValue += result.lowValue / 100;
// 低位取余
result.lowValue = result.lowValue % 100;
if (result.highValue >= HighCharArray.Length)
{
// 如果 高位大于 可用字符数组大小，溢出.
throw new OverflowException();
}
}
return result;
}
/// <summary>
/// 将序列号的字符串表示形式转换为它的等效 序列号对象。一个指示转换是否成功的返回值。
/// </summary>
/// <param name="strVal"></param>
/// <param name="outMySequence"></param>
/// <returns></returns>
public static bool TryParse(string strVal, out MySequence outMySequence)
{
outMySequence = new MySequence();
if (String.IsNullOrEmpty(strVal))
{
// 首先传入的参数要非空
return false;
}
if (strVal.Length != 3)
{
// 且 长度 = 3
return false;
}
if (!HighCharArray.Contains(strVal[0]))
{
// 首字母要 大写字母， 或者数字
// 也就是 在 高位的可用 字符 数组中.
return false;
}
if (!Char.IsDigit(strVal[1]) || !Char.IsDigit(strVal[2]))
{
// 后两个字母为数字.
return false;
}
// 高位 从 可用列表中找
outMySequence.highValue = Array.BinarySearch(HighCharArray, strVal[0]);
// 低位 转换为 整型
outMySequence.lowValue = Convert.ToInt32(strVal.Substring(1));
return true;
}
public void NewSequenct()
{
// 首先测试默认的构造函数. 结果应当等价于 001。
Assert.AreEqual("001", sequence.ToString());
// 再测试 几种不同的构造函数的方式，能否得出相同的序列号.
sequence = new MySequence('0', 1);
Assert.AreEqual("001", sequence.ToString());
}
public void NewSequenctArgument7()
{
// 字母 O 开头的，不允许.
MySequence sequence = new MySequence('O', 0);
// 由于上面的代码发生了异常，下面这句应该执行不到。
Assert.Fail("本测试应该触发一个异常。");
}
public void PlusOverflow()
{
// Z98 + 2 溢出.
sequence = new MySequence("Z99");
sequence = sequence + 2;
// 由于上面的代码发生了异常，下面这句应该执行不到。
Assert.Fail("本测试应该触发一个异常。");
}
public void Plus()
{
// 001 + 100 = 101
sequence = new MySequence("001");
sequence = sequence + 100;
Assert.AreEqual("101", sequence.ToString());
// A01 + 200 = C01
sequence = new MySequence("A01");
sequence = sequence + 200;
Assert.AreEqual("C01", sequence.ToString());
// N01 + 123 = P24
sequence = new MySequence("N01");
sequence = sequence + 123;
Assert.AreEqual("P24", sequence.ToString());
}
public void MinusMinusOverflow()
{
// 000-- 溢出.
sequence = new MySequence("000");
sequence--;
// 由于上面的代码发生了异常，下面这句应该执行不到。
Assert.Fail("本测试应该触发一个异常。");
}
public void MinusMinus()
{
// Z99-- = Z98
sequence = new MySequence("Z99");
sequence--;
Assert.AreEqual("Z98", sequence.ToString());
// P00-- = N99 ( 因为字母 O 被排除掉了)
sequence = new MySequence("P00");
sequence--;
Assert.AreEqual("N99", sequence.ToString());
// 001-- = 000
sequence = new MySequence("001");
sequence--;
Assert.AreEqual("000", sequence.ToString());
}
public void PlusPlus()
{
// 001++ = 002
sequence++;
// 001++ 后，结果为 002
Assert.AreEqual("002", sequence.ToString());
// 测试 999++ = A00
sequence = new MySequence("999");
sequence++;
Assert.AreEqual("A00", sequence.ToString());
// 测试 N99++ = P00 ( 因为字母 O 被排除掉了)
sequence = new MySequence("N99");
sequence++;
Assert.AreEqual("P00", sequence.ToString());
}
public void NewSequenctArgument9()
{
// 后面数字小于零的.
MySequence sequence = new MySequence('A', -1);
// 由于上面的代码发生了异常，下面这句应该执行不到。
Assert.Fail("本测试应该触发一个异常。");
}
public void PlusAndPlusPlus()
{
sequence = new MySequence("000");
MySequence seq2 = new MySequence("000");
// 遍历，确保每一个 ++ 操作的结果， 与 +1 的结果是一致的.
while (sequence != maxSequenct)
{
sequence++;
seq2 = seq2 + 1;
Assert.AreEqual(sequence, seq2);
}
}
public void NewSequenctArgument6()
{
MySequence sequence = new MySequence("AB0");
// 由于上面的代码发生了异常，下面这句应该执行不到。
Assert.Fail("本测试应该触发一个异常。");
}
