trackler 2.2.1.151 → 2.2.1.152

data/tracks/csharp/exercises/forth/Example.cs

@@ -3,24 +3,6 @@
 using System.Collections.Generic;
 using Sprache;
 
-public enum ForthError
-{
-    DivisionByZero,
-    StackUnderflow,
-    InvalidWord,
-    UnknownWord
-}
-
-public class ForthException : Exception
-{
-    public ForthException(ForthError error)
-    {
-        Error = error;
-    }
-
-    public ForthError Error { get; }
-}
-
 public class ForthState
 {
     public Stack<int> Stack { get; } = new Stack<int>();
@@ -31,7 +13,7 @@ public class ForthState
 
 public abstract class ForthDefinition
 {
-    public abstract void Evaluate(ForthState state);    
+    public abstract void Evaluate(ForthState state);
 }
 
 public abstract class TermDefinition : ForthDefinition
@@ -71,7 +53,7 @@ public UnaryOperation(string term) : base(term)
     public override void EvaluateDefaultTerm(ForthState state)
     {        
         if (state.Stack.Count < 1)
-            throw new ForthException(ForthError.StackUnderflow);
+            throw new InvalidOperationException();
 
         var operand = state.Stack.Pop();
 
@@ -91,7 +73,7 @@ public BinaryOperation(string term) : base(term)
     public override void EvaluateDefaultTerm(ForthState state)
     {
         if (state.Stack.Count <= 1)
-            throw new ForthException(ForthError.StackUnderflow);
+            throw new InvalidOperationException();
 
         var operand2 = state.Stack.Pop();
         var operand1 = state.Stack.Pop();
@@ -124,7 +106,7 @@ public Word(string str) : base(str)
     public override void EvaluateDefaultTerm(ForthState state)
     {
         if (!state.Mapping.ContainsKey(Term))
-            throw new ForthException(ForthError.UnknownWord);
+            throw new InvalidOperationException();
     }
 }
 
@@ -177,7 +159,7 @@ public class Division : BinaryOperation
     public override List<int> operation(int x, int y)
     {
         if (y == 0)
-            throw new ForthException(ForthError.DivisionByZero);
+            throw new InvalidOperationException();
 
         return new List<int> { x / y };
     }
@@ -186,33 +168,46 @@ public override List<int> operation(int x, int y)
 public class CustomTerm : ForthDefinition
 {
     private readonly string term;
-    private readonly IEnumerable<ForthDefinition> actions;
+    private readonly ForthDefinition[] actions;
 
     public CustomTerm(string term, IEnumerable<ForthDefinition> actions)
     {
         this.term = term;
-        this.actions = actions;
+        this.actions = actions.ToArray();
     }
 
     public override void Evaluate(ForthState state)
     {
-        int result;
-        if (int.TryParse(term, out result))
-            throw new ForthException(ForthError.InvalidWord);
+        if (int.TryParse(term, out _))
+            throw new InvalidOperationException();
+
+        var normalizedActions = new List<ForthDefinition>();
 
-        state.Mapping[term] = actions;
+        foreach (var action in actions)
+        {
+            if (action is Word word)
+                normalizedActions.AddRange(state.Mapping[word.Term]);
+            else
+                normalizedActions.Add(action);
+        }
+        
+        state.Mapping[term] = normalizedActions;
     }
 }
 
 public static class Forth
 {
-    public static string Eval(string input)
+    public static string Evaluate(string[] instructions)
     {
-        var expression = Expression.Parse(input);
         var state = new ForthState();
 
-        foreach (var definition in expression)
-            definition.Evaluate(state);
+        foreach (var instruction in instructions)
+        {
+            var expression = Expression.Parse(instruction);
+
+            foreach (var definition in expression)
+                definition.Evaluate(state);
+        }
 
         return state.ToString();
     }

data/tracks/csharp/exercises/forth/Forth.cs

@@ -1,26 +1,8 @@
 using System;
 
-public enum ForthError
-{
-    DivisionByZero,
-    StackUnderflow,
-    InvalidWord,
-    UnknownWord
-}
-
-public class ForthException : Exception
-{
-    public ForthException(ForthError error)
-    {
-        Error = error;
-    }
-
-    public ForthError Error { get; }
-}
-
 public static class Forth
 {
-    public static string Eval(string input)
+    public static string Evaluate(string[] instructions)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/forth/ForthTest.cs

@@ -1,120 +1,283 @@
-using Xunit;
+// This file was auto-generated based on version 1.6.0 of the canonical data.
+
+using Xunit;
+using System;
 
 public class ForthTest
 {
     [Fact]
-    public void No_input()
+    public void Parsing_and_numbers_numbers_just_get_pushed_onto_the_stack()
+    {
+        Assert.Equal("1 2 3 4 5", Forth.Evaluate(new[] { "1 2 3 4 5" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Addition_can_add_two_numbers()
+    {
+        Assert.Equal("3", Forth.Evaluate(new[] { "1 2 +" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Addition_errors_if_there_is_nothing_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "+" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Addition_errors_if_there_is_only_one_value_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "1 +" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtraction_can_subtract_two_numbers()
+    {
+        Assert.Equal("-1", Forth.Evaluate(new[] { "3 4 -" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtraction_errors_if_there_is_nothing_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "-" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtraction_errors_if_there_is_only_one_value_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "1 -" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiplication_can_multiply_two_numbers()
+    {
+        Assert.Equal("8", Forth.Evaluate(new[] { "2 4 *" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiplication_errors_if_there_is_nothing_on_the_stack()
     {
-        Assert.Equal("", Forth.Eval(""));
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "*" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Numbers_just_get_pushed_onto_the_stack()
+    public void Multiplication_errors_if_there_is_only_one_value_on_the_stack()
     {
-        Assert.Equal("1 2 3 4 5", Forth.Eval("1 2 3 4 5"));
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "1 *" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Non_word_characters_are_separators()
+    public void Division_can_divide_two_numbers()
     {
-        Assert.Equal("1 2 3 4 5 6 7", Forth.Eval("1\v2\t3\n4\r5 6\t7"));
+        Assert.Equal("4", Forth.Evaluate(new[] { "12 3 /" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Basic_arithmetic()
+    public void Division_performs_integer_division()
     {
-        Assert.Equal("-1", Forth.Eval("1 2 + 4 -"));
-        Assert.Equal("2", Forth.Eval("2 4 * 3 /"));
+        Assert.Equal("2", Forth.Evaluate(new[] { "8 3 /" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Division_by_zero()
+    public void Division_errors_if_dividing_by_zero()
     {
-        var exception = Assert.Throws<ForthException>(() => Forth.Eval("4 2 2 - /"));
-        Assert.Equal(ForthError.DivisionByZero, exception.Error);
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "4 0 /" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void dup()
+    public void Division_errors_if_there_is_nothing_on_the_stack()
     {
-        Assert.Equal("1 1", Forth.Eval("1 DUP"));
-        Assert.Equal("1 2 2", Forth.Eval("1 2 Dup"));
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "/" }));
+    }
 
-        var exception = Assert.Throws<ForthException>(() => Forth.Eval("dup"));
-        Assert.Equal(ForthError.StackUnderflow, exception.Error);
+    [Fact(Skip = "Remove to run test")]
+    public void Division_errors_if_there_is_only_one_value_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "1 /" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void drop()
+    public void Combined_arithmetic_addition_and_subtraction()
     {
-        Assert.Equal("", Forth.Eval("1 drop"));
-        Assert.Equal("1", Forth.Eval("1 2 drop"));
+        Assert.Equal("-1", Forth.Evaluate(new[] { "1 2 + 4 -" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Combined_arithmetic_multiplication_and_division()
+    {
+        Assert.Equal("2", Forth.Evaluate(new[] { "2 4 * 3 /" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Dup_copies_a_value_on_the_stack()
+    {
+        Assert.Equal("1 1", Forth.Evaluate(new[] { "1 dup" }));
+    }
 
-        var exception = Assert.Throws<ForthException>(() => Forth.Eval("drop"));
-        Assert.Equal(ForthError.StackUnderflow, exception.Error);
+    [Fact(Skip = "Remove to run test")]
+    public void Dup_copies_the_top_value_on_the_stack()
+    {
+        Assert.Equal("1 2 2", Forth.Evaluate(new[] { "1 2 dup" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void swap()
+    public void Dup_errors_if_there_is_nothing_on_the_stack()
     {
-        Assert.Equal("2 1", Forth.Eval("1 2 swap"));
-        Assert.Equal("1 3 2", Forth.Eval("1 2 3 swap"));
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "dup" }));
+    }
 
-        var exception1 = Assert.Throws<ForthException>(() => Forth.Eval("1 swap"));
-        Assert.Equal(ForthError.StackUnderflow, exception1.Error);
+    [Fact(Skip = "Remove to run test")]
+    public void Drop_removes_the_top_value_on_the_stack_if_it_is_the_only_one()
+    {
+        Assert.Equal("", Forth.Evaluate(new[] { "1 drop" }));
+    }
 
-        var exception2 = Assert.Throws<ForthException>(() => Forth.Eval("swap"));
-        Assert.Equal(ForthError.StackUnderflow, exception2.Error);
+    [Fact(Skip = "Remove to run test")]
+    public void Drop_removes_the_top_value_on_the_stack_if_it_is_not_the_only_one()
+    {
+        Assert.Equal("1", Forth.Evaluate(new[] { "1 2 drop" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void over()
+    public void Drop_errors_if_there_is_nothing_on_the_stack()
     {
-        Assert.Equal("1 2 1", Forth.Eval("1 2 over"));
-        Assert.Equal("1 2 3 2", Forth.Eval("1 2 3 over"));
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "drop" }));
+    }
 
-        var exception1 = Assert.Throws<ForthException>(() => Forth.Eval("1 over"));
-        Assert.Equal(ForthError.StackUnderflow, exception1.Error);
+    [Fact(Skip = "Remove to run test")]
+    public void Swap_swaps_the_top_two_values_on_the_stack_if_they_are_the_only_ones()
+    {
+        Assert.Equal("2 1", Forth.Evaluate(new[] { "1 2 swap" }));
+    }
 
-        var exception2 = Assert.Throws<ForthException>(() => Forth.Eval("over"));
-        Assert.Equal(ForthError.StackUnderflow, exception2.Error);
+    [Fact(Skip = "Remove to run test")]
+    public void Swap_swaps_the_top_two_values_on_the_stack_if_they_are_not_the_only_ones()
+    {
+        Assert.Equal("1 3 2", Forth.Evaluate(new[] { "1 2 3 swap" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Swap_errors_if_there_is_nothing_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "swap" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Swap_errors_if_there_is_only_one_value_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "1 swap" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Over_copies_the_second_element_if_there_are_only_two()
+    {
+        Assert.Equal("1 2 1", Forth.Evaluate(new[] { "1 2 over" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Over_copies_the_second_element_if_there_are_more_than_two()
+    {
+        Assert.Equal("1 2 3 2", Forth.Evaluate(new[] { "1 2 3 over" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Over_errors_if_there_is_nothing_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "over" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Over_errors_if_there_is_only_one_value_on_the_stack()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "1 over" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_can_consist_of_built_in_words()
+    {
+        Assert.Equal("1 1 1", Forth.Evaluate(new[] { ": dup-twice dup dup ;", "1 dup-twice" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_execute_in_the_right_order()
+    {
+        Assert.Equal("1 2 3", Forth.Evaluate(new[] { ": countup 1 2 3 ;", "countup" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_can_override_other_user_defined_words()
+    {
+        Assert.Equal("1 1 1", Forth.Evaluate(new[] { ": foo dup ;", ": foo dup dup ;", "1 foo" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_can_override_built_in_words()
+    {
+        Assert.Equal("1 1", Forth.Evaluate(new[] { ": swap dup ;", "1 swap" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_can_override_built_in_operators()
+    {
+        Assert.Equal("12", Forth.Evaluate(new[] { ": + * ;", "3 4 +" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_can_use_different_words_with_the_same_name()
+    {
+        Assert.Equal("5 6", Forth.Evaluate(new[] { ": foo 5 ;", ": bar foo ;", ": foo 6 ;", "bar foo" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_can_define_word_that_uses_word_with_the_same_name()
+    {
+        Assert.Equal("11", Forth.Evaluate(new[] { ": foo 10 ;", ": foo foo 1 + ;", "foo" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_cannot_redefine_numbers()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { ": 1 2 ;" }));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void User_defined_words_errors_if_executing_a_non_existent_word()
+    {
+        Assert.Throws<InvalidOperationException>(() => Forth.Evaluate(new[] { "foo" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Defining_a_new_word()
+    public void Case_insensitivity_dup_is_case_insensitive()
     {
-        Assert.Equal("1 1 1", Forth.Eval(": dup-twice dup dup ; 1 dup-twice"));
+        Assert.Equal("1 1 1 1", Forth.Evaluate(new[] { "1 DUP Dup dup" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Redefining_an_existing_word()
+    public void Case_insensitivity_drop_is_case_insensitive()
     {
-        Assert.Equal("1 1 1", Forth.Eval(": foo dup ; : foo dup dup ; 1 foo"));
+        Assert.Equal("1", Forth.Evaluate(new[] { "1 2 3 4 DROP Drop drop" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Redefining_an_existing_built_in_word()
+    public void Case_insensitivity_swap_is_case_insensitive()
     {
-        Assert.Equal("1 1", Forth.Eval(": swap dup ; 1 swap"));
+        Assert.Equal("2 3 4 1", Forth.Evaluate(new[] { "1 2 SWAP 3 Swap 4 swap" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Defining_words_with_odd_characters()
+    public void Case_insensitivity_over_is_case_insensitive()
     {
-        Assert.Equal("220371", Forth.Eval(": € 220371 ; €"));
+        Assert.Equal("1 2 1 2 1", Forth.Evaluate(new[] { "1 2 OVER Over over" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Defining_a_number()
+    public void Case_insensitivity_user_defined_words_are_case_insensitive()
     {
-        var exception = Assert.Throws<ForthException>(() => Forth.Eval(": 1 2 ;"));
-        Assert.Equal(ForthError.InvalidWord, exception.Error);
+        Assert.Equal("1 1 1 1", Forth.Evaluate(new[] { ": foo dup ;", "1 FOO Foo foo" }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Calling_a_non_existing_word()
+    public void Case_insensitivity_definitions_are_case_insensitive()
     {
-        var exception = Assert.Throws<ForthException>(() => Forth.Eval("1 foo"));
-        Assert.Equal(ForthError.UnknownWord, exception.Error);
+        Assert.Equal("1 1 1 1", Forth.Evaluate(new[] { ": SWAP DUP Dup dup ;", "1 swap" }));
     }
-}
+}