public void EqualsSameObjectTest()
{
var token = new BooleanToken(true);
Assert.True(token.Equals(token));
Assert.Equal(token, token);
}
private static void WriteBoolean(BooleanToken boolean, Stream outputStream)
{
var bytes = boolean.Data ? TrueBytes : FalseBytes;
outputStream.Write(bytes, 0, bytes.Length);
WriteWhitespace(outputStream);
}
public void EqualsDiffTypeTest()
{
var token = new BooleanToken(true);
Assert.False(token.Equals(1));
Assert.NotEqual((object)1, token);
}
public void EqualsNullTest()
{
var token = new BooleanToken(true);
Assert.False(token.Equals(null));
Assert.NotNull(token);
}
public Boolean AllowLiteral(out LiteralToken literal)
{
var current = m_enumerator.Current;
switch (current.Type)
{
case ParseEventType.Null:
literal = new NullToken(m_fileId, current.Line, current.Column);
m_enumerator.MoveNext();
return(true);
case ParseEventType.Boolean:
literal = new BooleanToken(m_fileId, current.Line, current.Column, (Boolean)current.Value);
m_enumerator.MoveNext();
return(true);
case ParseEventType.Number:
literal = new NumberToken(m_fileId, current.Line, current.Column, (Double)current.Value);
m_enumerator.MoveNext();
return(true);
case ParseEventType.String:
literal = new StringToken(m_fileId, current.Line, current.Column, (String)current.Value);
m_enumerator.MoveNext();
return(true);
}
literal = null;
return(false);
}
public void TestBooleanTokenAscii()
{
var stringBuilder = new LineStringBuilder();
var token = new BooleanToken(false);
token.WriteAscii(FbxVersion.v6_0, stringBuilder, 0);
Assert.Equal("F", stringBuilder.ToString());
}
public void EqualsDiffBoolTest()
{
var token1 = new BooleanToken(true);
var token2 = new BooleanToken(false);
Assert.False(token1.Equals(token2));
Assert.NotEqual(token1, token2);
}
public void TestBooleanTokenBinary()
{
using var memoryStream = new MemoryStream();
using var binaryWriter = new BinaryWriter(memoryStream);
var token = new BooleanToken(false);
token.WriteBinary(FbxVersion.v6_0, binaryWriter);
Assert.Equal(new byte[] { (byte)'C', (byte)'F' }, memoryStream.ToArray());
}
public void TestTokenProperties()
{
BooleanToken test = new BooleanToken(true);
IntegerToken resultIfTrue = new IntegerToken(1);
IntegerToken resultIfFalse = new IntegerToken(2);
ConditionalOperatorToken result = new ConditionalOperatorToken(0, test, resultIfTrue, resultIfFalse);
Assert.AreEqual(test, result.Test);
Assert.AreEqual(resultIfTrue, result.ResultIfTrue);
Assert.AreEqual(resultIfFalse, result.ResultIfFalse);
}
public void RunnableAttribute(ICommandInteraction writer, BooleanToken allow)
{
if (allow.Value)
{
monitor.CurrentBindingFlags |= BindingFlags.NonPublic;
}
else
{
monitor.CurrentBindingFlags &= ~BindingFlags.NonPublic;
}
}
protected T Visit(JToken token)
{
return(token switch
{
JObject jObject => Visit(jObject),
JProperty jProperty => Visit(jProperty),
JArray jArray => Visit(jArray),
DoubleToken doubleToken => Visit(doubleToken),
StringToken stringToken => Visit(stringToken),
BooleanToken booleanToken => Visit(booleanToken),
NullToken nullToken => Visit(nullToken),
_ => default
});
public void TestNotExpression()
{
string expression = "true:1:2";
InitCompiler(expression, 4);
BooleanToken test = new BooleanToken(true, 0);
compiler.Parent.AddChild(test);
Assert.IsFalse(parser.Parse(compiler));
Assert.AreEqual(4, compiler.Pos);
Assert.AreSame(root, compiler.Parent);
Assert.AreEqual(1, root.Children.Count);
Assert.AreSame(test, root.Children[0]);
}
public void TestMissingElse()
{
string expression = "true?1 2";
InitCompiler(expression, 4);
BooleanToken test = new BooleanToken(true, 0);
compiler.Parent.AddChild(test);
Assert.Throws <ParserException>(delegate {
parser.Parse(compiler);
});
Assert.AreEqual(4, compiler.Pos);
Assert.AreSame(root, compiler.Parent);
Assert.AreEqual(1, root.Children.Count);
Assert.AreSame(test, root.Children[0]);
}
public void TestValidExpression()
{
string expression = "true?1:2";
InitCompiler(expression, 4);
BooleanToken test = new BooleanToken(true, 0);
compiler.Parent.AddChild(test);
Assert.IsTrue(parser.Parse(compiler));
Assert.AreEqual(expression.Length, compiler.Pos);
Assert.AreSame(root, compiler.Parent);
Assert.AreEqual(1, root.Children.Count);
ConditionalOperatorToken expected = new ConditionalOperatorToken(4,
test, new IntegerToken(1, 5), new IntegerToken(2, 7));
Assert.AreEqual(expected, root.Children[0]);
}
public bool Parse(ExpressionCompiler compiler)
{
int i = compiler.Pos;
if (trueParser.Parse(compiler))
{
BooleanToken token = new BooleanToken(true, i);
compiler.Parent.AddChild(token);
return(true);
}
else if (falseParser.Parse(compiler))
{
BooleanToken token = new BooleanToken(false, i);
compiler.Parent.AddChild(token);
return(true);
}
else
{
return(false);
}
}
public static bool TryParseIdentifierOrCharToken(FbxAsciiFileInfo fbxAsciiFileInfo, out Token token)
{
var c = fbxAsciiFileInfo.PeekChar();
if (!c.IsIdentifierChar())
{
token = null;
return(false);
}
var stringBuilder = new StringBuilder();
while (c.IsIdentifierChar() && !fbxAsciiFileInfo.IsEndOfStream())
{
stringBuilder.Append(fbxAsciiFileInfo.ReadChar());
c = fbxAsciiFileInfo.PeekChar();
}
TryConsumeWhiteSpace(fbxAsciiFileInfo);
var identifier = stringBuilder.ToString();
if (fbxAsciiFileInfo.PeekChar() == ':')
{
fbxAsciiFileInfo.ReadChar();
token = new IdentifierToken(identifier);
return(true);
}
if (identifier.Equals("T") || identifier.Equals("F") || identifier.Equals("Y") || identifier.Equals("N"))
{
token = new BooleanToken(identifier.Equals("T") || identifier.Equals("Y"));
return(true);
}
throw new FbxException(fbxAsciiFileInfo, "Unexpected '" + identifier + "', expected ':' or a single-char literal");
}
public override string Visit(BooleanToken token)
{
return(token.ToString().ToLower());
}
public void ToStringTest()
{
var token = new BooleanToken(true);
Assert.Equal("Boolean: True", token.ToString());
}
public void SetVerbosity(ICommandInteraction writer, BooleanToken verbosity)
{
verbose = verbosity.Value;
setVerbosity(verbose);
}
public void TestFalse()
{
ValueToken result = new BooleanToken(false);
Assert.AreEqual(false, result.Value);
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn, params LiteralToken[] types)
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
var handler = new DefaultFunctionHandler(cpu);
var paramList = new List <FunctionCallParameter>();
foreach (var parameter in types)
{
FunctionCallParameterType paramType;
if (!Enum.TryParse(parameter.Value, out paramType))
{
throw new RecoverableException("{0} is not a proper parameter type.".FormatWith(parameter.Value));
}
paramList.Add(new FunctionCallParameter {
Type = paramType
});
}
handler.CallParameters = paramList.Take(paramList.Count - (traceReturn.Value ? 1 : 0));
handler.ReturnParameter = traceReturn.Value ? paramList.Last() : (FunctionCallParameter?)null;
if (traceReturn.Value)
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler);
}
else
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler);
}
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn, NumericToken numberOfParameters)
{
Execute(writer, cpuToken, functionName.Value, traceReturn.Value, (int)numberOfParameters.Value);
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn)
{
Execute(writer, cpuToken, functionName.Value, traceReturn.Value, null);
}
public void Run(PathToken path, BooleanToken token)
{
InnerRun(path.Value, token.Value);
}
public void TestTrue()
{
ValueToken result = new BooleanToken(true);
Assert.AreEqual(true, result.Value);
}
