public void It_Should_Store_The_Value()
{
// Arrange
var stringSymbol = new StringValue("String Test");
var result = stringSymbol.Value;
// Assert
Assert.That(result, Is.EqualTo("String Test"));
}
public void It_Should_Compare_Two_Unequal_Values()
{
// Arrange
var str1 = new StringValue("hello X");
var str2 = new StringValue("hello");
// Act
Assert.That(new EasyValueComparer().Equals(str1, str2), Is.False);
}
public void It_Should_Store_Null_As_Null()
{
// Arrange
var stringSymbol = new StringValue(null);
var result = stringSymbol.Value;
// Assert
Assert.That(result, Is.Null);
}
public void It_Should_Eval_A_Null_Value()
{
// Arrange
var stringSymbol = new StringValue(null);
var result = stringSymbol.Eval(new TemplateContext(), new List<Option<IExpressionConstant>>());
// Assert
Assert.That(result.SuccessValue<StringValue>(), Is.EqualTo(stringSymbol));
}
public void It_ShouldJ_Join_Two_Values()
{
// Arrange
var stringSymbol = new StringValue("Hello");
// Act
StringValue result = stringSymbol.Join(new StringValue("World"));
// Assert
Assert.That(result.StringVal, Is.EqualTo("HelloWorld"));
}
public void It_Should_Save_A_Variable()
{
// Arrange
var symbolTable = new SymbolTable();
var str = new StringValue("FOO");
// Act
symbolTable.DefineLocalVariable("foo", str);
// Assert
Assert.That(symbolTable.ReferenceLocalVariable("foo").SuccessValue<StringValue>(), Is.EqualTo(str));
}
public void It_Should_Cast_The_Value_From_One_Type_To_Another()
{
// Arrange
var castFilter = new CastFilter<StringValue, NumericValue>();
var inputObj = new StringValue("123");
// Act
var result = castFilter.Apply(new TemplateContext(),inputObj).SuccessValue<NumericValue>();
//result.Eval(new SymbolTableStack(new TemplateContext()), new List<IExpressionConstant>());
// Assert
Assert.That(result, Is.AssignableTo<NumericValue>());
Assert.That(result.DecimalValue, Is.EqualTo(123m));
}
private LiquidExpressionResult Contains(StringValue stringValue, IExpressionConstant expressionConstant)
{
String s = ValueCaster.RenderAsString(expressionConstant);
return LiquidExpressionResult.Success(stringValue.StringVal.Contains(s) ? new BooleanValue(true) : new BooleanValue(false));
}
public void Visit(StringValue stringValue)
{
_result += stringValue.ToString();
}
public StringValueIterableCreator(StringValue stringValue)
{
_stringValue = stringValue;
}
public void It_Should_Measure_The_Size_Of_A_String()
{
// Arrange
var strVal = new StringValue("1234567890");
var filter = new SizeFilter();
// Act
var result = filter.Apply(new TemplateContext(), strVal).SuccessValue<NumericValue>();
// Assert
Assert.That(result.Value, Is.EqualTo(strVal.StringVal.Count()));
}
public void A_String_With_No_Value_Should_Have_Zero_Length()
{
// Arrange
var strVal = new StringValue(null);
var filter = new SizeFilter();
// Act
var result = filter.Apply(new TemplateContext(), strVal).SuccessValue<NumericValue>();
// Assert
Assert.That(result.Value, Is.EqualTo(0));
}
/// <summary>
/// Return a new StringValue with str appended.
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public StringValue Join(StringValue str)
{
return new StringValue(StringVal + str.StringVal);
}
public void Visit(StringValue stringValue)
{
AppendTextToCurrentAccumulator(Render(stringValue));
}
public void It_Should_Handle_Casting_A_Null_Value()
{
// Arrange
var original = new StringValue(null);
// Act
var result = ValueCaster.Cast<StringValue, NumericValue>(original);
Assert.That(result.IsSuccess, Is.True);
// Assert
// is this what it should do?
Assert.That(result.SuccessValue<NumericValue>().IntValue, Is.EqualTo(0));
}
// TODO: this is inefficient and ugly and duplicates much of ArrayValue
private LiquidExpressionResult DoLookup(ITemplateContext ctx, StringValue strValue, IExpressionConstant indexProperty)
{
var strValues = strValue.StringVal.ToCharArray().Select(ch => new StringValue(ch.ToString()).ToOption()).ToList();
String propertyNameString = ValueCaster.RenderAsString(indexProperty);
int index;
if (propertyNameString.ToLower().Equals("first"))
{
index = 0;
}
else if (propertyNameString.ToLower().Equals("last"))
{
index = strValues.Count - 1;
}
else if (propertyNameString.ToLower().Equals("size"))
{
return LiquidExpressionResult.Success(NumericValue.Create(strValues.Count));
}
else
{
var maybeIndexResult = ValueCaster.Cast<IExpressionConstant, NumericValue>(indexProperty);
if (maybeIndexResult.IsError || !maybeIndexResult.SuccessResult.HasValue)
{
return LiquidExpressionResult.Error("invalid array index: " + propertyNameString);
}
else
{
index = maybeIndexResult.SuccessValue<NumericValue>().IntValue;
}
}
if (strValues.Count == 0)
{
//return LiquidExpressionResult.Error("Empty string: " + propertyNameString);
return LiquidExpressionResult.Success(new None<IExpressionConstant>()); // not an error in Ruby liquid.
}
return LiquidExpressionResult.Success(ArrayIndexer.ValueAt(strValues, index));
}
private static bool CheckIsEmpty(StringValue val)
{
return String.IsNullOrEmpty(val.StringVal);
}
private static bool CheckIsBlank(StringValue val)
{
String stringVal = val.StringVal;
return String.IsNullOrEmpty(stringVal.Trim());
}
public void It_Should_Cast_A_String_To_An_Array_Of_One_String()
{
// Arrange
var str = new StringValue("Hello");
// Act
var arrayResult = ValueCaster.Cast<StringValue, ArrayValue>(str);
Assert.That(arrayResult.IsError, Is.False);
// Assert
var arrValue = arrayResult.SuccessValue<ArrayValue>().ArrValue;
Assert.That(arrValue.Count, Is.EqualTo(1));
Assert.That(arrValue[0].Value, Is.EqualTo("Hello"));
}
private static String AsString(StringValue ex)
{
return "\"" + ex + "\"";
}
