public static void Main()
 {
     Test test = new Test();
      test.SetValue(3,5);
      int s = test.GetValue();
      Console.WriteLine("<<< " + s);
 }

        public void AsyncHTTPSICmd()
        {
            FileStream stream;
            stream = File.Create(outputFileHTTPSAsync);
            results = new StreamWriter(stream);
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();

            ICmd validICmd = new ICmd(TestGlobals.testServer, TestGlobals.validSerial);
            Test validTest = new Test(validICmd);
            validTest.setTestName("ValidSerial");
            validTest.setExpectedResult ("200");
            validTest.setType ("performance");
            List<Test> tests = new List<Test>();
            tests.Add(validTest);

            // Construct started tasks
            Task<double>[] tasks = new Task<double>[TestGlobals.maxReps];
            for (int i = 0; i < TestGlobals.maxReps; i++)
            {
                System.Threading.Thread.Sleep(TestGlobals.delay);
                tasks[i] = new HTTPSCalls().runTest(validTest, HTTPOperation.GET);
                Console.WriteLine("Test starting:" + i.ToString());
            }
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("All tests initialized, waiting on them to run as async");
            Console.WriteLine("------------------------------------------------------");
            Task.WaitAll(tasks);

            foreach (Task<double> nextResult in tasks)
            {
                results.WriteLine("Test Time," + nextResult.Result);
            }

            results.Close();
        }

 //**********************Test Messages***********************************
 public ActionResult AddTest(int pid)
 {
     ViewData["PatientId"] = pid;
     populateTestNames();
     var testmsg = new Test { TestDate = DateTime.UtcNow };
     return View(testmsg);
 }

 protected void Page_Load(object sender, EventArgs e)
 {
     Test test=new Test();
     DataTable table = test.Adomd();
     GridView1.DataSource = table;
     GridView1.DataBind();
 }

        public void TestClassMap()
        {
            // this test passes normally when the Test class is automapped
            // uncomment all or parts of the class map initialization code to test
            // the exceptions thrown for each non-compliant field or property

            if (__firstTime)
            {
                BsonClassMap.RegisterClassMap<Test>(cm =>
                {
                    cm.AutoMap();
                    // cm.MapField("literal");
                    // cm.MapField("readOnly");
                    // cm.MapField("notfound");
                    // cm.MapProperty("GetOnly");
                    // cm.MapProperty("SetOnly");
                    // cm.MapProperty("notfound");
                    // cm.MapMember(null);
                });
                __firstTime = false;
            }

            var test = new Test("x") { SetOnly = "y" };
            var bson = test.ToBson();
            var rehydrated = BsonSerializer.Deserialize<Test>(bson);
            Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
        }

        private bool IgnoreTestForBrowser(Test test, MemberInfo member)
        {
            bool ignoreTest = false;
            Attribute[] ignoreAttr = Reflect.GetAttributes(member, IgnoreBrowserAttributeTypeFullName, true);

            if (member != null && ignoreAttr != null)
            {
                // A test case might be ignored in more than one browser
                foreach (System.Attribute attr in ignoreAttr)
                {
                    object propVal = Reflect.GetPropertyValue(attr, "Value", BindingFlags.Public | BindingFlags.Instance);
                    object reasonValue = Reflect.GetPropertyValue(attr, "Reason", BindingFlags.Public | BindingFlags.Instance);

                    if (propVal != null)
                    {
                        string ignoreReason = "Ignoring browser " + EnvironmentManager.Instance.Browser.ToString() + ".";
                        if (reasonValue != null)
                        {
                            ignoreReason = ignoreReason + " " + reasonValue.ToString();
                        }

                        Browser browser = (Browser)propVal;
                        if (browser.Equals(EnvironmentManager.Instance.Browser) || browser.Equals(Browser.All) || IsRemoteInstanceOfBrowser(browser))
                        {
                            ignoreTest = true;
                        }
                    }

                }
            }

            return ignoreTest;
        }

        public override Test.Framework.TestResult Run(Test.Framework.TestCase testCase)
        {
            DDS.IDomainParticipant participant;
			DDS.SubscriberQos subscriberQosHolder = null;
            DDS.ISubscriber subscriber;
            Test.Framework.TestResult result;
            DDS.ITopic topic;
            participant = (DDS.IDomainParticipant)testCase.ResolveObject("participant");
            topic = (DDS.ITopic)testCase.ResolveObject("topic");
            result = new Test.Framework.TestResult("Initialization success", string.Empty, Test.Framework.TestVerdict.Pass,
                Test.Framework.TestVerdict.Fail);
            if (participant == null || topic == null)
            {
                System.Console.Error.WriteLine("participant or topic = null");
                result.Result = "precondition not met";
                return result;
            }

            if (participant.GetDefaultSubscriberQos(ref subscriberQosHolder) != DDS.ReturnCode.Ok)
            {
                result.Result = "could not get default SubscriberQos";
                return result;
            }
            subscriber = participant.CreateSubscriber(subscriberQosHolder);//, null, DDS.StatusKind.Any);
            if (subscriber == null)
            {
                result.Result = "could create a Subscriber";
                return result;
            }
            testCase.RegisterObject("subscriber", subscriber);
            result.Result = "Initialization success.";
            result.Verdict = Test.Framework.TestVerdict.Pass;
            return result;
        }

        private void pictureBox2_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(textBox1.Text))
                {
                    textBox1.Clear();
                    MessageBox.Show("Nama harus diisi", "WARNING!!!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
                else
                {
                    data dat = new data(textBox1.Text);
                    db.OpenConn();
                    try
                    {
                        string sql = string.Concat("INSERT INTO Users " + "([nama]) VALUES " + "('"+textBox1.Text+"')");
                        db.execQuery(sql);
                        //MessageBox.Show("Nama Add Sukses");
                        Test tst = new Test();
                        this.Close();
                        tst.Show();
                    data.cektestbuttonabout = false;
                    data.cektestbuttoninfo = false;
                }
                    catch (Exception)
                    {
                        //MessageBox.Show("Data tidak dimasukkan");
                    }
                    db.CloseConn();

                }
        }

 private static int Main()
 {
     Test test = new Test(20.0d);
     test.Print();
     Console.WriteLine("*** PASSED ***");
     return 100;
 }

 static void Main()
 {
     Test test = new Test();
     test.Changed = new MyMessage();
     test.No = 10;
     test.No = 50;
 }

 public void SerializeToXmlDocument_TestModel_ReturnsXmlDocument()
 {
     var model = new Test { Name = "John Doe", Birth = new DateTime(1950, 1, 1) };
     var document = XmlHelper.SerializeToXmlDocument(model);
     Assert.IsNotNull(document);
     Assert.AreEqual("John Doe", document.DocumentElement.FirstChild.FirstChild.Value);
 }

 public static int Main()
 {
     Test staticsTest = new Test();        
     staticsTest.RunTest();
     Console.WriteLine(100 == staticsTest.retVal ? "Test Passed":"Test Failed");
     return staticsTest.retVal;
 }

        public IHttpActionResult Post(Test test)
        {
            this.studentDataManagement.Tests.Add(test);
            this.studentDataManagement.SaveChanges();

            return this.Ok("New Test added");
        }

        public IHttpActionResult PutTest(int id, Test test)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != test.Id)
            {
                return BadRequest();
            }

            db.Entry(test).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TestExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

 private void test_Click(object sender, EventArgs e)
 {
     this.Hide();
     Test test = new Test(this);
     test.SetDesktopLocation(this.DesktopLocation.X, this.DesktopLocation.Y);
     test.Show();
 }

 unsafe static void Main()
     {
         Test test = new Test();
         Test* p   = &test;
         p->x      = 9;
         System.Console.WriteLine (test.x);
     }

    static int Main()
    {
	Test t = new Test();
	t.RunTest();
	return t.CheckRet();
	
    }

        static void Main(string[] args)
        {
            var test = new Test();
            test.Start();

            Console.ReadKey();
        }

 public override Test.Framework.TestResult Run(Test.Framework.TestCase testCase)
 {
     DDS.IDomainParticipant participant;
     mod.tstTypeSupport typeSupport;
     DDS.TopicQos topicQos;
     DDS.ITopic topic;
     DDS.ReturnCode rc;
     Test.Framework.TestResult result;
     participant = (DDS.IDomainParticipant)testCase.ResolveObject("participant");
     typeSupport = (mod.tstTypeSupport)testCase.ResolveObject("typeSupport");
     topicQos = (DDS.TopicQos)testCase.ResolveObject("topicQos");
     result = new Test.Framework.TestResult("Initialization 3 success", string.Empty,
         Test.Framework.TestVerdict.Pass, Test.Framework.TestVerdict.Fail);
     rc = typeSupport.RegisterType(participant, "my_other_type");
     if (rc != DDS.ReturnCode.Ok)
     {
         result.Result = "Register type failed.";
         return result;
     }
     topic = participant.CreateTopic("my_other_topic", "my_other_type", topicQos);//, null, 0);
     if (topic == null)
     {
         result.Result = "Topic could not be created.";
         return result;
     }
     testCase.RegisterObject("otherTopic", topic);
     result.Result = "Initialization success.";
     result.Verdict = Test.Framework.TestVerdict.Pass;
     return result;
 }

        /// <summary>
        /// Creates a test node as a top-most level test
        /// </summary>
        /// 
        /// <param name="Name">Test name</param>
        /// <param name="Description">A short description of the test</param>
        public ExtentTest(string Name, string Description)
        {
            _test = new Test();

            _test.Name = Name;
            _test.Description = Description;
        }