The Mad Economist

----------------------------------------------------------------------

#light

open System
open System.Collections.Generic
open System.IO
open Xunit
open MathMod

[<Fact>]
let PV_1000() =
     let vals = [-1000.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 1100.0]
     let pv0 = presentValue vals 0.1
     Assert.InRange(pv0,(0.0 - 0.0001),(0.0 + 0.0001))

----------------------------------------------------------------------

Notice, I open Xunit (note the capitalization).  I don't know why xUnit is called Xunit ???

Anyway, a test is structured with a tag  [<Fact>].

You then define a method -- I call it PV_1000() in this example.

Caution:  You must append the open parentheses at the end of the function, otherwise the Test Runner won't identify it as a test.  The program will still compile, it's just that the Test Runner won't find it.  It only took me two friggin' hours to figure this out.

In my test I have a series of numbers whose present value I know should be zero (0.0).  The statement:

Assert.InRange(pv0,(0.0 - 0.0001),(0.0 + 0.0001))

Asserts that the result of the present value calculation (pv0) is in the range of 0 +/- 0.0001.  (I can't use equality here because I am using floating point numbers.)  The Test Runner application will find any method tagged as tag  [<Fact>] and run it.  The Assert statement will be executed and will succeed or fail.

So, let's try it.  I first compile the program in F#.  I then run the Test Runner (xunit.gui.exe).  I then open my assembly:

When I open my assembly, the Test Runner shows the tests it has identified.

To run, the test(s), I just click the run button.

The Test Runner then runs the test and indicates if it has passed or failed:

Here it has passed.

Now here is a test I know will fail:

[<Fact>]
let PV_1000_Fail() =
     let vals = [-1000.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 100.0; 1100.0]
     let pv0 = presentValue vals 0.12
     Assert.InRange(pv0,(0.0-0.0001),(0.0+0.0001))

I have changed the discount rate to 12% which should make the present value less than zero.  I recompile the program and run the Test Runner.

Here's what a failure looks like:

The results screen show the failure and the reason it failed.  Note that the present value is now -113.00 -- this value fails the test.

Cool Huh?

Now, the test I really want to write is a test of my mortgage calculator:

-------------------------------------------------------------

[<Fact>]
let mortgageCalc() =

    let mortgage = 200000.0
    let n = 360
    let i = 0.06

    let ones = List.init n (fun one -> 1.0)

    let pv0 = presentValue ones (i/12.0)

    let levelPayment = mortgage / pv0

    //
    //Now Test
    //
    let payments = List.init n (fun one -> levelPayment)

    let pv2 = presentValue payments (i/12.0)
    Assert.InRange(pv2,(mortgage-0.0001),(mortgage+0.0001))

-------------------------------------------------------------

In this test, I calculate my level payment for a $200,000 mortgage over 360 months at 6.00% interest.  I then calculate create a stream of payments equal to my level payment.  I then discount that stream back to the present.  The result is pv2.  I then Assert that the result pv2 is equal (within a tolerance) of my original mortgage.

I compile and run.

We Pass!