public IArithmeticLogicUnit Create(Action <IByte> updateAcc, Action <Caez> updateFlags)
{
var not = new Not();
var and = new And();
var nAnd = new NAnd(not, and);
var or = new Or(not, nAnd);
var xOr = new XOr(not, nAnd);
var byteFactory = new ByteFactory(new Base10Converter());
return(new ArithmeticLogicUnit(
new ByteXOr(xOr, byteFactory),
new ByteOr(or, byteFactory),
new ByteAnd(and, byteFactory),
new Inverter(not, byteFactory),
new ByteAdder(new BitAdder(xOr, or, and), byteFactory),
new ByteEnabler(and, byteFactory),
and,
new IsZeroGate(or, not),
new ByteDecoder(new Decoder(not, and), byteFactory),
new ByteRightShifter(byteFactory),
new ByteLeftShifter(byteFactory),
or,
new AluWire(byteFactory),
new ByteComparator(new BitComparator(xOr, and, or, not), byteFactory), updateFlags,
updateAcc, byteFactory));
}
public void CloneTest()
{
var exp = new XOr(new Bool(true), new Bool(false));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public void TestXOr()
{
{
var res = new XOr(
BooleanFalse.Instance,
BooleanFalse.Instance
);
Assert.AreEqual(false, res.Value);
}
{
var res = new XOr(
BooleanTrue.Instance,
BooleanFalse.Instance
);
Assert.AreEqual(true, res.Value);
}
{
var res = new Or(
BooleanFalse.Instance,
BooleanTrue.Instance
);
Assert.AreEqual(true, res.Value);
}
{
var res = new XOr(
BooleanTrue.Instance,
BooleanTrue.Instance
);
Assert.AreEqual(false, res.Value);
}
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>The result of analysis.</returns>
public string Analyze(XOr exp)
{
if (exp.Parent is BinaryExpression)
{
return(ToString(exp, "({0} xor {1})"));
}
return(ToString(exp, "{0} xor {1}"));
}
public void Setup()
{
_and = new And();
_not = new Not();
_nAnd = new NAnd(_not, _and);
_or = new Or(_not, _nAnd);
_xOr = new XOr(_not, _nAnd);
_bitComparator = new BitComparator(_xOr, _and, _or, _not);
}
public void XOr_SuccessfullyCreates_XOrExpression_Test()
{
//Arrange
var True = _expressions.Bool(true);
var TrueXOrTrueEx = new XOr <IContext>(True, True);
//Act
var sut = _expressions.XOr(True, True);
//Assert
Assert.Equal(TrueXOrTrueEx.Interpret(_context), sut.Interpret(_context));
}
public void Setup()
{
_byteFactory = new ByteFactory(new Base10Converter());
_and = new And();
_not = new Not();
_nAnd = new NAnd(_not, _and);
_or = new Or(_not, _nAnd);
_xOr = new XOr(_not, _nAnd);
_bitComparator = new BitComparator(_xOr, _and, _or, _not);
_byteToBase10 = new ByteToBase10Converter(_byteFactory, new Base10Converter());
_sut = new ByteComparator(_bitComparator, _byteFactory);
}
public void XOr()
{
//Arrange
var trueXOrTrue = new XOr <IContext>(new ConstantBool <IContext>(true), new ConstantBool <IContext>(true));
var trueXOrFalse = new XOr <IContext>(new ConstantBool <IContext>(true), new ConstantBool <IContext>(false));
var falseXOrTrue = new XOr <IContext>(new ConstantBool <IContext>(false), new ConstantBool <IContext>(true));
var falseXOrFalse = new XOr <IContext>(new ConstantBool <IContext>(false), new ConstantBool <IContext>(false));
//Act
var sut1 = trueXOrTrue.Interpret(_context);
var sut2 = trueXOrFalse.Interpret(_context);
var sut3 = falseXOrTrue.Interpret(_context);
var sut4 = falseXOrFalse.Interpret(_context);
//Assert
Assert.False(sut1);
Assert.True(sut2);
Assert.True(sut3);
Assert.False(sut4);
}
public override Verb CreateVerb(string[] tokens)
{
Color(position, tokens[1].Length, Whitespaces);
var operation = tokens[2];
Color(operation.Length, KeyWords);
Color(tokens[3].Length, Structures);
var index = position + length;
Block block;
if (GetExpression(source, index, "')'").Assign(out block, out index))
{
Verb verb;
switch (operation)
{
case "and":
verb = new And();
break;
case "or":
verb = new Or();
break;
case "xor":
verb = new XOr();
break;
default:
return(null);
}
result.Verbs = new List <Verb>
{
verb,
new Push(block)
};
overridePosition = index;
return(new NullOp());
}
return(null);
}
public void ResultTypeNumVarTest()
{
var exp = new XOr(new Number(1), new Variable("x"));
Assert.Equal(ExpressionResultType.Number, exp.ResultType);
}
public void ResultTypeBoolVarTest()
{
var exp = new XOr(new Bool(true), new Variable("x"));
Assert.Equal(ExpressionResultType.Boolean, exp.ResultType);
}
public void ResultTypeNumberNumberTest()
{
var exp = new XOr(new Number(2), new Number(4));
Assert.Equal(ExpressionResultType.Number, exp.ResultType);
}
public void ResultTypeBoolBoolTest()
{
var exp = new XOr(new Bool(true), new Bool(false));
Assert.Equal(ExpressionResultType.Boolean, exp.ResultType);
}
public void ExecuteTest2()
{
var exp = new XOr(new Number(1), new Number(2.5));
Assert.Equal(2.0, exp.Execute());
}
public void ExecuteTest4()
{
var exp = new XOr(new Bool(false), new Bool(true));
Assert.Equal(true, exp.Execute());
}
public void TestXOrComplexNumberBoolException()
{
var exp = new XOr(new ComplexNumber(1, 1), new Bool(false));
TestBinaryException(exp);
}
public void TestXOrUndefined()
{
var exp = new XOr(Variable.X, new Variable("y"));
Test(exp, ResultType.Undefined);
}
public void TestXOrNumber()
{
var exp = new XOr(new Number(1), new Number(2));
Test(exp, ResultType.Number);
}
public void XOrXOrToStringTest()
{
var exp = new XOr(new Bool(true), new XOr(new Bool(true), new Bool(true)));
Assert.Equal("True xor (True xor True)", exp.ToString(commoonFormatter));
}
public void TestXOrComplexNumberException()
{
var exp = new XOr(new ComplexNumber(1, 1), new Number(1));
TestBinaryException(exp);
}
public void TestXOrBoolean()
{
var exp = new XOr(new Bool(true), new Bool(false));
Test(exp, ResultType.Boolean);
}
public void ReturnsCorrectNewBit(bool expected, bool[] bits)
{
var sut = new XOr(new Not(), new NAnd(new Not(), new And()));
Assert.AreEqual(expected, sut.Apply(bits));
}
public void ExecuteTest4()
{
var exp = new XOr(new Bool(false), new Bool(true));
Assert.True((bool)exp.Execute());
}
public void TestXOrException()
{
var exp = new XOr(new ComplexNumber(1, 2), new ComplexNumber(2, 3));
TestException(exp);
}
public void ResultTypeVerVarTest()
{
var exp = new XOr(new Variable("y"), new Variable("x"));
Assert.Equal(ExpressionResultType.Number | ExpressionResultType.Boolean, exp.ResultType);
}
public void TestXOrBoolComplexNumberException()
{
var exp = new XOr(new Bool(true), new ComplexNumber(1, 1));
TestBinaryException(exp);
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>
/// The result of analysis.
/// </returns>
/// <exception cref="System.NotSupportedException">Always.</exception>
public virtual TResult Analyze(XOr exp)
{
throw new NotSupportedException();
}
public void ExecuteResultIsNotSupported()
{
var exp = new XOr(new ComplexNumber(1), new ComplexNumber(2));
Assert.Throws <ResultIsNotSupportedException>(() => exp.Execute());
}
