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 + "\""; }