Comments on: Java.beyond

By: Ulf Wiger

Ulf Wiger — Tue, 16 Sep 2008 16:22:50 +0000

Unfortunately, the test code is so verbose that one cannot bare to look at it (no offense, guys

Here’s a version together with a unit test using QuickCheck.
It tests both valid and some invalid inputs
(not sure how to get the formatting right, though):

-module(grades).
-export([grades/1, test/0]).
-include_lib(“eqc/include/eqc.hrl”).

-define(VALID_GRADES, “abcdfABCDF”).

grades(N) when is_integer(N), N > 100 -> invalid;
grades(N) when N == “A”; N == “a”; is_integer(N), N >= 90 -> “A”;
grades(N) when N == “B”; N == “b”; is_integer(N), N >= 80 -> “B”;
grades(N) when N == “C”; N == “c”; is_integer(N), N >= 70 -> “C”;
grades(N) when N == “D”; N == “d”; is_integer(N), N >= 60 -> “D”;
grades(N) when N == “F”; N == “f”; is_integer(N), N >= 0 -> “F”;
grades(_) -> invalid.

test() ->
?FORALL(
V, oneof([valid,invalid]),
?LET(R, result(V),
expected(V, catch grades(R), R))).

result(valid) ->
oneof([choose(0,100),
[oneof(?VALID_GRADES)] % string of length 1
]);
result(invalid) ->
oneof([?LET(N, nat(), -(1+N)),
?LET(N, nat(), N + 101),
[?SUCHTHAT(C,choose(0,255),
not(lists:member(C,?VALID_GRADES)))] % string
]).

expected(valid,invalid,_) -> false;
expected(invalid,invalid,_) -> true;
expected(valid,G,R) when is_integer(R) ->
{Min,Max} = interval(G),
R >= Min andalso R =< Max;
expected(valid,G,R) ->
string:to_upper(R) == G.

interval(“A”) -> {90,100};
interval(“B”) -> {80,89};
interval(“C”) -> {70,79};
interval(“D”) -> {60,69};
interval(“F”) -> {0,59}.

By: Mark

Mark — Tue, 16 Sep 2008 13:51:52 +0000

@Kevin, @Steve,

To defend Kevin, in my implementation I didn’t follow Stuart’s code exactly, and opted to allow grades over 100 and I also didn’t note the restriction in my description of the problem. What of the case where extra credit is awarded, so the grade is over 100?

So based on the acceptance criteria, this either is, or is not a bug.

Therefore, I think both implementations are equally valid.

I do appreciate seeing the test code in Erlang. It is a topic that I think is not addressed often enough, how to apply TDD to Erlang.

By: DSmith

DSmith — Tue, 16 Sep 2008 01:18:43 +0000

A slight variation on a previous post…
-module(grades). -export([grade/1]).

grade(N) when is_integer(N), N >= 90 -> "A"; grade(N) when is_integer(N), N >= 80 -> "B"; grade(N) when is_integer(N), N >= 70 -> "C"; grade(N) when is_integer(N), N >= 60 -> "D"; grade(N) when is_integer(N), N >= 0 -> "F"; grade([G]) when G >= $a, G = [G-32]; grade([G]) when G >= $A, G = [G]; grade(T) -> throw({invalid_grade, T}).

By: Kevin Smith

Kevin Smith — Tue, 16 Sep 2008 00:06:36 +0000

@Steve – You sir are correct. I should’ve read the problem more closely. I totally missed that. Ah well, I still think the code’s not too bad for only spending a few minutes on it.

By: Steve Vinoski

Steve Vinoski — Mon, 15 Sep 2008 20:08:58 +0000

@Mitchell: unfortunately the presence of the test code in the examples above is not enough to prevent bugs. What happens if you pass 101, for example? The originals in the other languages on Stuart’s page would call that an error. My code gets that case right.

If it’s test code you want, here’s my version with the tests attached:

-module(grades). -export([letter_grade/1, test/0]).


letter_grade(N)

 when is_integer(N), N >= 0, N =< 100 ->

  L = ["F", "F", "F", "F", "F", "F", "D",

   "C", "B", "A", "A"],

  lists:nth(trunc(N/10)+1, L);

letter_grade([G|_]=L)

 when length(L) == 1, G >= $A, G =< $F, G =/= $E ->

  L;

letter_grade([G|_]=L)

 when length(L) == 1, G >= $a, G =< $f, G =/= $e ->

  string:to_upper(L);

letter_grade(_) ->

  throw(invalid_grade).
test() ->

  ok = check_grade("A", 90, 100),

  ok = check_grade("B", 80, 89),

  ok = check_grade("C", 70, 79),

  ok = check_grade("D", 60, 69),

  ok = check_grade("F", 0, 59),

  ok = try letter_grade(101)

   catch throw:invalid_grade -> ok;

    _:_ -> fail

   end,

  ok = try letter_grade(-1)

   catch throw:invalid_grade -> ok;

    _:_ -> fail

   end,

  ok = try letter_grade("E")

   catch throw:invalid_grade -> ok;

     _:_ -> fail

   end,

  ok = try letter_grade("Aa")

   catch throw:invalid_grade -> ok;

     _:_ -> fail

   end,

  ok = try letter_grade(a)

   catch throw:invalid_grade -> ok;

    _:_ -> fail

   end.

check_grade(Grade, Start, End) -> lists:map(fun(G) -> Grade = letter_grade(G) end, lists:seq(Start, End)), ok.