using VSpec.Matchers;

public class AbcSpec : VSpec.Spec<MyTestedClass> {
  public override void define() {
    before_each(() => {
      // Before each in that spec
    });

    after_each(() => {
      // After each in that spec
    });

    describe(".something", () => {
      // Equivalent to let in RSpec
      this["lazyvar"] = () => { return "original"; };

      context("if something happened", () => {
        // Test cases will have access to the closest let
        this["lazyvar"] = () => { return "overridden"; };

        before_each(() => {
          // Before each in that context
        });

        after_each(() => {
          // After each in that context
        });

        xit("should do whatever", () => {
          // I am pending spec
        });

        it("should ensure that let is working", () => {
          expect(this["lazyvar"]).to<eq>("overridden");
        });

        it("should fail because of invalid var name", () => {
          expect(this["lazyvar-wrongname"]).to<eq>("123");
        });

        it("should fail because of failed match", () => {
          expect(this["lazyvar"]).to<be_null>();
        });
      });

      it("should throw an arror and keep runner running", () => {
        throw new ThreadError.AGAIN("Abc");
      });

      // Pending context
      xcontext("if something happened", () => {
        it("should print variables ", () => {
          // I won't be called as parent context is pending
        });
      });
    });
  }
}

public static int main(string[] args) {
  VSpec.add(typeof(AbcSpec));

  VSpec.before_all(() => {
    // Do something before running all specs
  });

  VSpec.after_all(() => {
    // Do something after running all specs
  });

  VSpec.before_each(() => {
    // Do something before each spec
  });

  VSpec.after_each(() => {
    // Do something after each spec
  });


  VSpec.verbose = true; // Print output of all GLib logging functions

  return VSpec.run();
}