public void Delete()
        {
            Guid TempGuid = Guid.NewGuid();

            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <string>("@StringValue1", "Test String");
                Helper.AddParameter <string>("@StringValue2", "Test String");
                Helper.AddParameter <long>("@BigIntValue", 12345);
                Helper.AddParameter <bool>("@BitValue", true);
                Helper.AddParameter <decimal>("@DecimalValue", 1234.5678m);
                Helper.AddParameter <float>("@FloatValue", 12345.6534f);
                Helper.AddParameter <Guid>("@GUIDValue", TempGuid);
                Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
                Helper.ExecuteNonQuery();
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("delete from TestTable where @ID=ID", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <int>("@ID", 1);
                Helper.ExecuteNonQuery();
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteReader();
                if (Helper.Read())
                {
                    Assert.Fail("Nothing was deleted");
                }
            }
        }
 public void All()
 {
     Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_")
             .Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_");
     ObjectClass1 TempObject = null;
     Utilities.Random.Random Rand = new Utilities.Random.Random();
     using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
     {
         for (int x = 0; x < 100; ++x)
         {
             TempObject = new ObjectClass1();
             TempObject.StringValue = Rand.Next<string>(new RegexStringGenerator(10));
             TempObject.BoolValue = Rand.Next<bool>();
             TempObject.FloatValue = (float)Rand.NextDouble();
             TempObject.LongValue =Rand.Next();
             ORM.Save<ObjectClass1, int>(TempObject);
         }
         TempObject = null;
         IEnumerable<ObjectClass1> Objects = ORM.All<ObjectClass1>();
         Assert.Equal(100, Objects.Count());
     }
 }
        public void CommandInsertNullString()
        {
            Guid TempGuid = Guid.NewGuid();

            Utilities.SQL.Command TempCommand = new Utilities.SQL.Command("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@0,@1,@2,@3,@4,@5,@6,@7)", CommandType.Text, "Test String", null, 12345, true, 1234.5678m, 12345.6534f, new DateTime(1999, 12, 31), TempGuid);
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper(TempCommand, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false"))
            {
                Helper.ExecuteNonQuery();
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteReader();
                if (Helper.Read())
                {
                    Assert.Equal("Test String", Helper.GetParameter <string>("StringValue1", ""));
                    Assert.Equal("This is a null string", Helper.GetParameter <string>("StringValue2", "This is a null string"));
                    Assert.Equal(12345, Helper.GetParameter <long>("BigIntValue", 0));
                    Assert.Equal(true, Helper.GetParameter <bool>("BitValue", false));
                    Assert.Equal(1234.5678m, Helper.GetParameter <decimal>("DecimalValue", 0));
                    Assert.Equal(12345.6534f, Helper.GetParameter <float>("FloatValue", 0));
                    Assert.Equal(TempGuid, Helper.GetParameter <Guid>("GUIDValue", Guid.Empty));
                    Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter <DateTime>("DateTimeValue", DateTime.Now));
                }
                else
                {
                    Assert.False(true, "Nothing was inserted");
                }
            }
        }
Example #4
0
        public void Delete()
        {
            using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
            {
                TestObject.Map(x => x.ID, "ID_")
                .Map(x => x.StringValue, "StringValue_", 100)
                .Map(x => x.FloatValue, "FloatValue_")
                .Map(x => x.BoolValue, "BoolValue_")
                .Map(x => x.LongValue, "LongValue_")
                .Map(x => x.StringMaxValue, "StringMaxValue_", -1);
                Utilities.Random.Random Rand       = new Utilities.Random.Random();
                ObjectClass1            TempObject = new ObjectClass1();
                TempObject.StringValue    = "Test";
                TempObject.BoolValue      = false;
                TempObject.FloatValue     = 1.5f;
                TempObject.LongValue      = 12;
                TempObject.StringMaxValue = Rand.Next <string>(new RegexStringGenerator(6000));
                TestObject.Save <int>(TempObject);
                Assert.Equal(1, TestObject.Delete(TempObject));

                using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) AS ItemCount FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
                {
                    Helper.ExecuteReader();
                    if (Helper.Read())
                    {
                        Assert.Equal(0, Helper.GetParameter <int>("ItemCount", -1));
                    }
                    else
                    {
                        Assert.False(true, "Nothing was inserted");
                    }
                }
            }
        }
Example #5
0
 public void Insert()
 {
     using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
     {
         TestObject.Map(x => x.ID, "ID_")
         .Map(x => x.StringValue, "StringValue_", 100)
         .Map(x => x.FloatValue, "FloatValue_")
         .Map(x => x.BoolValue, "BoolValue_")
         .Map(x => x.LongValue, "LongValue_");
         ObjectClass1 TempObject = new ObjectClass1();
         TempObject.StringValue = "Test String";
         TempObject.BoolValue   = true;
         TempObject.FloatValue  = 1234.5f;
         TempObject.LongValue   = 12345;
         TempObject.ID          = TestObject.Insert <int>(TempObject);
         using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
         {
             Helper.ExecuteReader();
             if (Helper.Read())
             {
                 Assert.Equal("Test String", Helper.GetParameter <string>("StringValue_", ""));
                 Assert.Equal(1234.5f, Helper.GetParameter <float>("FloatValue_", 0));
                 Assert.Equal(true, Helper.GetParameter <bool>("BoolValue_", false));
                 Assert.Equal(12345, Helper.GetParameter <long>("LongValue_", 0));
                 Assert.Equal(TempObject.ID, Helper.GetParameter <int>("ID_", 0));
             }
             else
             {
                 Assert.Fail("Nothing was inserted");
             }
         }
     }
 }
 public void Creation()
 {
     Utilities.SQL.ParameterTypes.AndParameter TestObject = new Utilities.SQL.ParameterTypes.AndParameter(new EqualParameter <int>(1, "Left"), new EqualParameter <int>(2, "Right"));
     Assert.Equal("(Left=@Left AND Right=@Right)", TestObject.ToString());
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Assert.DoesNotThrow(() => TestObject.AddParameter(Helper));
     }
 }
        public void BulkCopy2()
        {
            Guid TempGuid = Guid.NewGuid();
            List <BulkCopyObject> Objects = new List <BulkCopyObject>();

            for (int x = 0; x < 100; ++x)
            {
                BulkCopyObject TempObject = new BulkCopyObject();
                TempObject.BigIntValue   = 12345;
                TempObject.BitValue      = true;
                TempObject.DateTimeValue = new DateTime(1999, 12, 31);
                TempObject.DecimalValue  = 1234.5678m;
                TempObject.FloatValue    = 12345.6534f;
                TempObject.GUIDValue     = TempGuid;
                TempObject.ID            = x + 1;
                TempObject.StringValue1  = "Test String";
                TempObject.StringValue2  = "Test String";
                Objects.Add(TempObject);
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteBulkCopy(Objects, "TestTable");
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteReader();
                bool Inserted = false;
                while (Helper.Read())
                {
                    Inserted = true;
                    Assert.Equal("Test String", Helper.GetParameter <string>("StringValue1", ""));
                    Assert.Equal("Test String", Helper.GetParameter <string>("StringValue2", ""));
                    Assert.Equal(12345, Helper.GetParameter <long>("BigIntValue", 0));
                    Assert.Equal(true, Helper.GetParameter <bool>("BitValue", false));
                    Assert.Equal(1234.5678m, Helper.GetParameter <decimal>("DecimalValue", 0));
                    Assert.Equal(12345.6534f, Helper.GetParameter <float>("FloatValue", 0));
                    Assert.Equal(TempGuid, Helper.GetParameter <Guid>("GUIDValue", Guid.Empty));
                    Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter <DateTime>("DateTimeValue", DateTime.Now));
                }
                if (!Inserted)
                {
                    Assert.False(true, "Nothing was inserted");
                }
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) as [ItemCount] FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteReader();
                if (Helper.Read())
                {
                    Assert.Equal(100, Helper.GetParameter <int>("ItemCount", 0));
                }
                else
                {
                    Assert.False(true, "Nothing was inserted");
                }
            }
        }
 public void Connect()
 {
     Assert.DoesNotThrow <Exception>(() =>
     {
         using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
         {
         }
     });
 }
 public void Creation()
 {
     Utilities.SQL.ParameterTypes.OrParameter TestObject = new Utilities.SQL.ParameterTypes.OrParameter(new EqualParameter<int>(1, "Left"), new EqualParameter<int>(2, "Right"));
     Assert.Equal("(Left=@Left OR Right=@Right)", TestObject.ToString());
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Assert.DoesNotThrow<Exception>(() => TestObject.AddParameter(Helper));
     }
 }
 public void BulkCopy()
 {
     Guid TempGuid=Guid.NewGuid();
     List<BulkCopyObject> Objects = new List<BulkCopyObject>();
     for (int x = 0; x < 100; ++x)
     {
         BulkCopyObject TempObject = new BulkCopyObject();
         TempObject.BigIntValue = 12345;
         TempObject.BitValue = true;
         TempObject.DateTimeValue = new DateTime(1999, 12, 31);
         TempObject.DecimalValue = 1234.5678m;
         TempObject.FloatValue = 12345.6534f;
         TempObject.GUIDValue = TempGuid;
         TempObject.ID = x+1;
         TempObject.StringValue1 = "Test String";
         TempObject.StringValue2 = "Test String";
         Objects.Add(TempObject);
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteBulkCopy(Objects.ToDataTable(),"TestTable");
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader();
         bool Inserted=false;
         while (Helper.Read())
         {
             Inserted=true;
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
             Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
             Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
             Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
             Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
             Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
             Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
         }
         if(!Inserted)
         {
             Assert.Fail("Nothing was inserted");
         }
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) as [ItemCount] FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader();
         if (Helper.Read())
         {
             Assert.Equal(100, Helper.GetParameter<int>("ItemCount", 0));
         }
         else
         {
             Assert.Fail("Nothing was inserted");
         }
     }
 }
 public void Dispose()
 {
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=master;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.Batch().AddCommand("ALTER DATABASE TestDatabase SET OFFLINE WITH ROLLBACK IMMEDIATE", CommandType.Text)
             .AddCommand("ALTER DATABASE TestDatabase SET ONLINE", CommandType.Text)
             .AddCommand("DROP DATABASE TestDatabase", CommandType.Text);
         Helper.ExecuteNonQuery();
     }
 }
Example #12
0
 public Mapping()
 {
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID_ INT PRIMARY KEY IDENTITY,StringValue_ NVARCHAR(100),LongValue_ BIGINT,BoolValue_ BIT,FloatValue_ FLOAT,StringMaxValue_ NVARCHAR(MAX))", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteNonQuery();
     }
 }
 public void Dispose()
 {
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("ALTER DATABASE TestDatabase SET OFFLINE WITH ROLLBACK IMMEDIATE", "Data Source=localhost;Initial Catalog=master;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteNonQuery();
         Helper.Command = "ALTER DATABASE TestDatabase SET ONLINE";
         Helper.ExecuteNonQuery();
         Helper.Command = "DROP DATABASE TestDatabase";
         Helper.ExecuteNonQuery();
     }
 }
 public SQLHelper()
 {
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID INT PRIMARY KEY IDENTITY,StringValue1 NVARCHAR(100),StringValue2 NVARCHAR(MAX),BigIntValue BIGINT,BitValue BIT,DecimalValue DECIMAL(12,6),FloatValue FLOAT,DateTimeValue DATETIME,GUIDValue UNIQUEIDENTIFIER)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteNonQuery();
     }
 }
 public void Creation()
 {
     Parameter<int> TestObject = new Parameter<int>(12, "ID");
     Assert.Equal("ID", TestObject.ID);
     Assert.Equal(12, TestObject.Value);
     Assert.Equal("@", TestObject.ParameterStarter);
     Assert.Equal("ID=@ID", TestObject.ToString());
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Assert.DoesNotThrow<Exception>(() => TestObject.AddParameter(Helper));
     }
 }
        public SQLHelper()
        {
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteNonQuery();

            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID INT PRIMARY KEY IDENTITY,StringValue1 NVARCHAR(100),StringValue2 NVARCHAR(MAX),BigIntValue BIGINT,BitValue BIT,DecimalValue DECIMAL(12,6),FloatValue FLOAT,DateTimeValue DATETIME,GUIDValue UNIQUEIDENTIFIER)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteNonQuery();
            }
        }
        public Mapping()
        {
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteNonQuery();

            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID_ INT PRIMARY KEY IDENTITY,StringValue_ NVARCHAR(100),LongValue_ BIGINT,BoolValue_ BIT,FloatValue_ FLOAT,StringMaxValue_ NVARCHAR(MAX))", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteNonQuery();
            }
        }
 public void Creation()
 {
     Utilities.SQL.ParameterTypes.LikeParameter TestObject = new Utilities.SQL.ParameterTypes.LikeParameter("ASDF", "ID", 100);
     Assert.Equal("ID", TestObject.ID);
     Assert.Equal("ASDF", TestObject.Value);
     Assert.Equal("@", TestObject.ParameterStarter);
     Assert.Equal("ID LIKE @ID", TestObject.ToString());
     Assert.Equal(100, TestObject.Length);
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Assert.DoesNotThrow(() => TestObject.AddParameter(Helper));
     }
 }
Example #19
0
        public void Creation()
        {
            EqualParameter <int> TestObject = new EqualParameter <int>(12, "ID");

            Assert.Equal("ID", TestObject.ID);
            Assert.Equal(12, TestObject.Value);
            Assert.Equal("@", TestObject.ParameterStarter);
            Assert.Equal("ID=@ID", TestObject.ToString());
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Assert.DoesNotThrow(() => TestObject.AddParameter(Helper));
            }
        }
 public void Creation()
 {
     Utilities.SQL.ParameterTypes.StringEqualParameter TestObject = new Utilities.SQL.ParameterTypes.StringEqualParameter("ASDF", "ID", 100);
     Assert.Equal("ID", TestObject.ID);
     Assert.Equal("ASDF", TestObject.Value);
     Assert.Equal("@", TestObject.ParameterStarter);
     Assert.Equal("ID=@ID", TestObject.ToString());
     Assert.Equal(100, TestObject.Length);
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Assert.DoesNotThrow(() => Helper.AddParameter(TestObject));
     }
 }
 public void Creation()
 {
     BetweenParameter<int> TestObject = new BetweenParameter<int>(10, 12, "ID");
     Assert.Equal("ID", TestObject.ID);
     Assert.Equal(10, TestObject.Min);
     Assert.Equal(12, TestObject.Max);
     Assert.Equal("@", TestObject.ParameterStarter);
     Assert.Equal("ID BETWEEN @IDMin AND @IDMax", TestObject.ToString());
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Assert.DoesNotThrow(() => Helper.AddParameter(TestObject));
     }
 }
        public void Update()
        {
            Guid TempGuid = Guid.NewGuid();

            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <string>("@StringValue1", "Test");
                Helper.AddParameter <string>("@StringValue2", "Test");
                Helper.AddParameter <long>("@BigIntValue", 123);
                Helper.AddParameter <bool>("@BitValue", false);
                Helper.AddParameter <decimal>("@DecimalValue", 1234);
                Helper.AddParameter <float>("@FloatValue", 12345);
                Helper.AddParameter <Guid>("@GUIDValue", Guid.NewGuid());
                Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 1, 1));
                Helper.ExecuteNonQuery();
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("update TestTable set StringValue1=@StringValue1,StringValue2=@StringValue2,BigIntValue=@BigIntValue,BitValue=@BitValue,DecimalValue=@DecimalValue,FloatValue=@FloatValue,DateTimeValue=@DateTimeValue,GUIDValue=@GUIDValue", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <string>("@StringValue1", "Test String");
                Helper.AddParameter <string>("@StringValue2", "Test String");
                Helper.AddParameter <long>("@BigIntValue", 12345);
                Helper.AddParameter <bool>("@BitValue", true);
                Helper.AddParameter <decimal>("@DecimalValue", 1234.5678m);
                Helper.AddParameter <float>("@FloatValue", 12345.6534f);
                Helper.AddParameter <Guid>("@GUIDValue", TempGuid);
                Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
                Helper.ExecuteNonQuery();
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.ExecuteReader();
                if (Helper.Read())
                {
                    Assert.Equal("Test String", Helper.GetParameter <string>("StringValue1", ""));
                    Assert.Equal("Test String", Helper.GetParameter <string>("StringValue2", ""));
                    Assert.Equal(12345, Helper.GetParameter <long>("BigIntValue", 0));
                    Assert.Equal(true, Helper.GetParameter <bool>("BitValue", false));
                    Assert.Equal(1234.5678m, Helper.GetParameter <decimal>("DecimalValue", 0));
                    Assert.Equal(12345.6534f, Helper.GetParameter <float>("FloatValue", 0));
                    Assert.Equal(TempGuid, Helper.GetParameter <Guid>("GUIDValue", Guid.Empty));
                    Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter <DateTime>("DateTimeValue", DateTime.Now));
                }
                else
                {
                    Assert.Fail("Nothing was inserted");
                }
            }
        }
 public void CreateDatabase()
 {
     Database Database = new Database("TestDatabase");
     Table TestTable = Database.AddTable("TestTable");
     TestTable.AddColumn<string>("ID_", DbType.Int32);
     TestTable.AddColumn<string>("Value1", DbType.String, 100);
     TestTable.AddColumn<string>("Value2", DbType.Double);
     Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2) VALUES (@ID_,@Value1,@Value2)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<int>("@ID_", 1);
         Helper.AddParameter<string>("@Value1", "Test String");
         Helper.AddParameter<float>("@Value2", 3.0f);
         Assert.Equal(1, Helper.ExecuteNonQuery());
     }
 }
 public void All()
 {
     using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
         TestObject.Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_")
             .Map(x => x.StringMaxValue, "StringMaxValue_");
         Utilities.Random.Random Rand = new Utilities.Random.Random(12345);
         ObjectClass1 TempObject = new ObjectClass1();
         TempObject.StringValue = "Test String";
         TempObject.BoolValue = true;
         TempObject.FloatValue = 1234.5f;
         TempObject.LongValue = 12345;
         TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
         Helper2.Save<ObjectClass1, int>(TempObject);
         IEnumerable<ObjectClass1> Objects = Helper2.All<ObjectClass1>();
         Assert.Equal(1, Objects.Count());
         foreach (ObjectClass1 Item in Objects)
         {
             Assert.Equal("Test String", Item.StringValue);
             Assert.Equal(1234.5f, Item.FloatValue);
             Assert.Equal(true, Item.BoolValue);
             Assert.Equal(12345, Item.LongValue);
             Assert.Equal(1, Item.ID);
             Assert.Equal(TempObject.StringMaxValue, Item.StringMaxValue);
         }
         List<ObjectClass1> Objects2 = new List<ObjectClass1>();
         Rand = new Utilities.Random.Random();
         for (int x = 0; x < 10; ++x)
         {
             TempObject = new ObjectClass1();
             TempObject.StringValue = Rand.Next<string>(new RegexStringGenerator(10));
             TempObject.BoolValue = Rand.Next<bool>();
             TempObject.FloatValue = (float)Rand.NextDouble();
             TempObject.LongValue = Rand.Next(0, 100);
             TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
             Objects2.Add(TempObject);
         }
         Helper2.Save<ObjectClass1, int>(Objects2);
         Objects = Helper2.All<ObjectClass1>();
         Assert.Equal(11, Objects.Count());
     }
 }
Example #25
0
        public void CreateDatabase()
        {
            Database Database  = new Database("TestDatabase");
            Table    TestTable = Database.AddTable("TestTable");

            TestTable.AddColumn <string>("ID_", DbType.Int32);
            TestTable.AddColumn <string>("Value1", DbType.String, 100);
            TestTable.AddColumn <string>("Value2", DbType.Double);
            Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2) VALUES (@ID_,@Value1,@Value2)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <int>("@ID_", 1);
                Helper.AddParameter <string>("@Value1", "Test String");
                Helper.AddParameter <float>("@Value2", 3.0f);
                Assert.Equal(1, Helper.ExecuteNonQuery());
            }
        }
Example #26
0
 public void Creation()
 {
     Assert.DoesNotThrow(() =>
     {
         using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
         {
             using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
             {
                 using (Mapping <ObjectClass1> TestObject2 = new Mapping <ObjectClass1>(TestObject, Helper))
                 {
                 }
             }
         }
         using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("TestTable", "ID_"))
         {
         }
     });
 }
 public void ClearParameters()
 {
     Guid TempGuid = Guid.NewGuid();
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<string>("@StringValue1", "Test");
         Helper.AddParameter<string>("@StringValue2", "Test");
         Helper.AddParameter<long>("@BigIntValue", 123);
         Helper.AddParameter<bool>("@BitValue", false);
         Helper.AddParameter<decimal>("@DecimalValue", 1234);
         Helper.AddParameter<float>("@FloatValue", 12345);
         Helper.AddParameter<Guid>("@GUIDValue", Guid.NewGuid());
         Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 1, 1));
         Helper.ClearParameters();
         Helper.AddParameter<string>("@StringValue1", "Test String");
         Helper.AddParameter<string>("@StringValue2", "Test String");
         Helper.AddParameter<long>("@BigIntValue", 12345);
         Helper.AddParameter<bool>("@BitValue", true);
         Helper.AddParameter<decimal>("@DecimalValue", 1234.5678m);
         Helper.AddParameter<float>("@FloatValue", 12345.6534f);
         Helper.AddParameter<Guid>("@GUIDValue", TempGuid);
         Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader();
         if (Helper.Read())
         {
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
             Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
             Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
             Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
             Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
             Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
             Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
         }
         else
         {
             Assert.Fail("Nothing was inserted");
         }
     }
 }
        public void OutputParamter()
        {
            Guid TempGuid = Guid.NewGuid();

            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <string>("@StringValue1", "Test String");
                Helper.AddParameter <string>("@StringValue2", "Test String");
                Helper.AddParameter <long>("@BigIntValue", 12345);
                Helper.AddParameter <bool>("@BitValue", true);
                Helper.AddParameter <decimal>("@DecimalValue", 1234.5678m);
                Helper.AddParameter <float>("@FloatValue", 12345.6534f);
                Helper.AddParameter <Guid>("@GUIDValue", TempGuid);
                Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
                Helper.ExecuteNonQuery();
            }
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SET @ASD=12345", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <long>("@ASD", Direction: ParameterDirection.Output);
                Helper.ExecuteNonQuery();
                Assert.Equal(12345, Helper.GetParameter <long>("@ASD", 0, ParameterDirection.Output));
            }
        }
Example #29
0
        public void UpdateDatabase()
        {
            Database Database  = new Database("TestDatabase");
            Table    TestTable = Database.AddTable("TestTable");

            TestTable.AddColumn <string>("ID_", DbType.Int32);
            TestTable.AddColumn <string>("Value1", DbType.String, 100);
            TestTable.AddColumn <string>("Value2", DbType.Double);
            Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
            Database Database2 = new Database("TestDatabase");

            TestTable = Database2.AddTable("TestTable");
            TestTable.AddColumn <string>("ID_", DbType.Int32);
            TestTable.AddColumn <string>("Value1", DbType.String, 100);
            TestTable.AddColumn <string>("Value2", DbType.Double);
            TestTable.AddColumn <string>("Value3", DbType.Boolean);
            Utilities.SQL.SQLServer.SQLServer.UpdateDatabase(Database2, Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
            using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2,Value3) VALUES (@ID_,@Value1,@Value2,@Value3)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Helper.AddParameter <int>("@ID_", 1);
                Helper.AddParameter <string>("@Value1", "Test String");
                Helper.AddParameter <float>("@Value2", 3.0f);
                Helper.AddParameter <bool>("@Value3", true);
                Assert.Equal(1, Helper.ExecuteNonQuery());
            }
            Database Database3 = Utilities.SQL.SQLServer.SQLServer.GetDatabaseStructure("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");

            Assert.Equal(Database2.Tables[0].Name, Database3.Tables[0].Name);
            Assert.Equal(Database2.Tables[0].Columns.Count, Database3.Tables[0].Columns.Count);
            Assert.Equal(DbType.Int32, Database3.Tables[0].Columns.First(x => x.Name == "ID_").DataType);
            Assert.Equal(DbType.String, Database3.Tables[0].Columns.First(x => x.Name == "Value1").DataType);
            Assert.Equal(DbType.Double, Database3.Tables[0].Columns.First(x => x.Name == "Value2").DataType);
            Assert.Equal(100, Database3.Tables[0].Columns.First(x => x.Name == "Value1").Length);
            Assert.Equal(4, Database3.Tables[0].Columns.First(x => x.Name == "ID_").Length);
            Assert.Equal(8, Database3.Tables[0].Columns.First(x => x.Name == "Value2").Length);
        }
 public void OutputParamter()
 {
     Guid TempGuid = Guid.NewGuid();
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<string>("@StringValue1", "Test String");
         Helper.AddParameter<string>("@StringValue2", "Test String");
         Helper.AddParameter<long>("@BigIntValue", 12345);
         Helper.AddParameter<bool>("@BitValue", true);
         Helper.AddParameter<decimal>("@DecimalValue", 1234.5678m);
         Helper.AddParameter<float>("@FloatValue", 12345.6534f);
         Helper.AddParameter<Guid>("@GUIDValue", TempGuid);
         Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SET @ASD=12345", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<long>("@ASD", Direction: ParameterDirection.Output);
         Helper.ExecuteNonQuery();
         Assert.Equal(12345, Helper.GetParameter<long>("@ASD", 0, ParameterDirection.Output));
     }
 }
 public void CommandInsertNullString()
 {
     Guid TempGuid = Guid.NewGuid();
     Utilities.SQL.Command TempCommand = new Utilities.SQL.Command("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@0,@1,@2,@3,@4,@5,@6,@7)", CommandType.Text, "Test String", null, 12345, true, 1234.5678m, 12345.6534f, new DateTime(1999, 12, 31), TempGuid);
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper(TempCommand, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false"))
     {
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader();
         if (Helper.Read())
         {
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
             Assert.Equal("This is a null string", Helper.GetParameter<string>("StringValue2", "This is a null string"));
             Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
             Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
             Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
             Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
             Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
             Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
         }
         else
         {
             Assert.Fail("Nothing was inserted");
         }
     }
 }
 public void CachedQuery()
 {
     Guid TempGuid = Guid.NewGuid();
     for (int x = 0; x < 100; ++x)
     {
         using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
         {
             Helper.AddParameter<string>("@StringValue1", "Test String")
                 .AddParameter<string>("@StringValue2", "Test String")
                 .AddParameter<long>("@BigIntValue", 12345)
                 .AddParameter<bool>("@BitValue", true)
                 .AddParameter<decimal>("@DecimalValue", 1234.5678m)
                 .AddParameter<float>("@FloatValue", 12345.6534f)
                 .AddParameter<Guid>("@GUIDValue", TempGuid)
                 .AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31))
                 .ExecuteNonQuery();
         }
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader(Cache: true);
         int Count=0;
         while (Helper.Read())
         {
             ++Count;
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
             Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
             Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
             Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
             Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
             Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
             Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
         }
         Assert.Equal(100, Count);
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader(Cache: true);
         int Count = 0;
         while (Helper.Read())
         {
             ++Count;
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
             Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
             Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
             Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
             Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
             Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
             Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
         }
         Assert.Equal(100, Count);
     }
 }
 public void Update()
 {
     using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
         TestObject.Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_")
             .Map(x => x.StringMaxValue, "StringMaxValue_");
         Utilities.Random.Random Rand = new Utilities.Random.Random(12346);
         ObjectClass1 TempObject = new ObjectClass1();
         TempObject.StringValue = "Test";
         TempObject.BoolValue = false;
         TempObject.FloatValue = 1.5f;
         TempObject.LongValue = 12;
         TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
         TempObject.ID = Helper2.Insert<ObjectClass1, int>(TempObject);
         Rand = new Utilities.Random.Random(12345);
         TempObject.StringValue = "Test String";
         TempObject.BoolValue = true;
         TempObject.FloatValue = 1234.5f;
         TempObject.LongValue = 12345;
         TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
         Helper2.Update(TempObject);
         using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
         {
             Helper.ExecuteReader();
             if (Helper.Read())
             {
                 Assert.Equal("Test String", Helper.GetParameter<string>("StringValue_", ""));
                 Assert.Equal(1234.5f, Helper.GetParameter<float>("FloatValue_", 0));
                 Assert.Equal(true, Helper.GetParameter<bool>("BoolValue_", false));
                 Assert.Equal(12345, Helper.GetParameter<long>("LongValue_", 0));
                 Assert.Equal(TempObject.ID, Helper.GetParameter<int>("ID_", 0));
                 Assert.Equal(TempObject.StringMaxValue, Helper.GetParameter<string>("StringMaxValue_", ""));
             }
             else
             {
                 Assert.False(true,"Nothing was inserted");
             }
         }
     }
 }
 public void Scalar()
 {
     using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
         TestObject.Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_")
             .Map(x => x.StringMaxValue, "StringMaxValue_");
         Utilities.Random.Random Rand = new Utilities.Random.Random(12345);
         for (int x = 0; x < 100; ++x)
         {
             ObjectClass1 TempObject = new ObjectClass1();
             TempObject.StringValue = "Test String";
             TempObject.BoolValue = true;
             TempObject.FloatValue = 1234.5f;
             TempObject.LongValue = 12345;
             TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
             string StringMaxValue = TempObject.StringMaxValue;
             Helper2.Save<ObjectClass1, int>(TempObject);
         }
         int ASD = Helper2.Scalar<ObjectClass1, int>("SELECT COUNT(*) FROM TestTable", CommandType.Text);
         Assert.Equal(100, ASD);
         ASD = Helper2.Scalar<ObjectClass1, int>("COUNT(*)");
         Assert.Equal(100, ASD);
     }
 }
        public void Paged2()
        {
            using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
            {
                Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
                TestObject.Map(x => x.ID, "ID_")
                    .Map(x => x.StringValue, "StringValue_")
                    .Map(x => x.FloatValue, "FloatValue_")
                    .Map(x => x.BoolValue, "BoolValue_")
                    .Map(x => x.LongValue, "LongValue_")
                    .Map(x => x.StringMaxValue, "StringMaxValue_");
                List<ObjectClass1> Objects2 = new List<ObjectClass1>();
                Utilities.Random.Random Rand = new Utilities.Random.Random();
                for (int x = 0; x < 115; ++x)
                {
                    ObjectClass1 TempObject = new ObjectClass1();
                    TempObject.StringValue = Rand.Next<string>(new RegexStringGenerator(10));
                    TempObject.BoolValue = Rand.Next<bool>();
                    TempObject.FloatValue = (float)Rand.NextDouble();
                    TempObject.LongValue = Rand.Next(0, 100);
                    TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
                    Objects2.Add(TempObject);
                }
                Helper2.Save<ObjectClass1, int>(Objects2);
                IEnumerable<ObjectClass1> Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable");
                Assert.Equal(25, Objects.Count());
                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 1);
                Assert.Equal(25, Objects.Count());
                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 2);
                Assert.Equal(25, Objects.Count());
                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 3);
                Assert.Equal(25, Objects.Count());
                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 4);
                Assert.Equal(15, Objects.Count());
                Assert.Equal(5, Helper2.PageCount<ObjectClass1>("SELECT * FROM TestTable"));

                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", "", 25, 0, null, null, false, new EqualParameter<int>(50, "ID"));
                Assert.Equal(25, Objects.Count());
                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", "", 25, 1, null, null, false, new EqualParameter<int>(50, "ID"));
                Assert.Equal(25, Objects.Count());
                Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", "", 25, 2, null, null, false, new EqualParameter<int>(50, "ID"));
                Assert.Equal(15, Objects.Count());
                Assert.Equal(3, Helper2.PageCount<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", 25, false, new EqualParameter<int>(50, "ID")));
            }
        }
        public void Delete()
        {
            using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("","Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false",CommandType.Text))
            {
                Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
                TestObject.Map(x => x.ID, "ID_")
                    .Map(x => x.StringValue, "StringValue_")
                    .Map(x => x.FloatValue, "FloatValue_")
                    .Map(x => x.BoolValue, "BoolValue_")
                    .Map(x => x.LongValue, "LongValue_")
                    .Map(x => x.StringMaxValue, "StringMaxValue_");
                Utilities.Random.Random Rand = new Utilities.Random.Random();
                ObjectClass1 TempObject = new ObjectClass1();
                TempObject.StringValue = "Test";
                TempObject.BoolValue = false;
                TempObject.FloatValue = 1.5f;
                TempObject.LongValue = 12;
                TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
                Helper2.Save<ObjectClass1, int>(TempObject);
                Assert.Equal(1, Helper2.Delete<ObjectClass1>(TempObject));

                using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) AS ItemCount FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
                {
                    Helper.ExecuteReader();
                    if (Helper.Read())
                    {
                        Assert.Equal(0, Helper.GetParameter<int>("ItemCount", -1));
                    }
                    else
                    {
                        Assert.False(true,"Nothing was inserted");
                    }
                }
            }
        }
 public void Creation()
 {
     Assert.DoesNotThrow(() =>
     {
         Mapping<ObjectClass1> TestObject = new Mapping<ObjectClass1>("TestTable", "ID_");
         using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
         {
             Mapping<ObjectClass1> TestObject2 = new Mapping<ObjectClass1>(TestObject);
         }
         TestObject = new Mapping<ObjectClass1>("TestTable", "ID_");
     });
 }
 public void Delete()
 {
     Guid TempGuid = Guid.NewGuid();
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<string>("@StringValue1", "Test String");
         Helper.AddParameter<string>("@StringValue2", "Test String");
         Helper.AddParameter<long>("@BigIntValue", 12345);
         Helper.AddParameter<bool>("@BitValue", true);
         Helper.AddParameter<decimal>("@DecimalValue", 1234.5678m);
         Helper.AddParameter<float>("@FloatValue", 12345.6534f);
         Helper.AddParameter<Guid>("@GUIDValue", TempGuid);
         Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("delete from TestTable where @ID=ID", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<int>("@ID", 1);
         Helper.ExecuteNonQuery();
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader();
         if (Helper.Read())
         {
             Assert.Fail("Nothing was deleted");
         }
     }
 }
 public void Save()
 {
     Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable","ID_")
             .Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_");
     ObjectClass1 TempObject = new ObjectClass1();
     using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
     {
         TempObject.StringValue = "Test";
         TempObject.BoolValue = false;
         TempObject.FloatValue = 1.5f;
         TempObject.LongValue = 12;
         ORM.Save<ObjectClass1, int>(TempObject);
         TempObject.StringValue = "Test String";
         TempObject.BoolValue = true;
         TempObject.FloatValue = 1234.5f;
         TempObject.LongValue = 12345;
         ORM.Save<ObjectClass1,int>(TempObject);
     }
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteReader();
         if (Helper.Read())
         {
             Assert.Equal("Test String", Helper.GetParameter<string>("StringValue_", ""));
             Assert.Equal(1234.5f, Helper.GetParameter<float>("FloatValue_", 0));
             Assert.Equal(true, Helper.GetParameter<bool>("BoolValue_", false));
             Assert.Equal(12345, Helper.GetParameter<long>("LongValue_", 0));
             Assert.Equal(TempObject.ID, Helper.GetParameter<int>("ID_", 0));
         }
         else
         {
             Assert.False(true,"Nothing was inserted");
         }
     }
 }
 public void Dispose()
 {
     Utilities.SQL.MicroORM.MicroORM.ClearAllMappings();
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("ALTER DATABASE TestDatabase SET OFFLINE WITH ROLLBACK IMMEDIATE", "Data Source=localhost;Initial Catalog=master;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.ExecuteNonQuery();
         Helper.Command = "ALTER DATABASE TestDatabase SET ONLINE";
         Helper.ExecuteNonQuery();
         Helper.Command = "DROP DATABASE TestDatabase";
         Helper.ExecuteNonQuery();
     }
 }
 public void AnyDifferentParameterTypes()
 {
     Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_")
             .Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_");
     for (int x = 0; x < 30; ++x)
     {
         using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
         {
             ObjectClass1 TempObject = new ObjectClass1();
             TempObject.StringValue = "Test String";
             TempObject.BoolValue = true;
             TempObject.FloatValue = 1234.5f;
             TempObject.LongValue = x;
             TempObject.ID = ORM.Insert<ObjectClass1, int>(TempObject);
         }
     }
     using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
     {
         ObjectClass1 TempObject = ORM.Any<ObjectClass1>("*", null, null, false, new EqualParameter<long>(20, "LongValue_"));
         Assert.Equal(21, TempObject.ID);
         Assert.Equal(20, TempObject.LongValue);
         IEnumerable<ObjectClass1> TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new NotEqualParameter<long>(20, "LongValue_"));
         Assert.Equal(29, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new BetweenParameter<long>(20, 25, "LongValue_"));
         Assert.Equal(6, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new AndParameter(new BetweenParameter<long>(20, 25, "LongValue_"), new NotEqualParameter<long>(20, "LongValue_")));
         Assert.Equal(5, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new OrParameter(new BetweenParameter<long>(20, 25, "LongValue_"), new EqualParameter<long>(29, "LongValue_")));
         Assert.Equal(7, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new LikeParameter("Test%", "StringValue_", 100));
         Assert.Equal(30, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new LikeParameter("Test2%", "StringValue_", 100));
         Assert.Equal(0, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new StringEqualParameter("Test String", "StringValue_", 100));
         Assert.Equal(30, TempObjects.Count());
         TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null,false, new StringNotEqualParameter("Test String", "StringValue_", 100));
         Assert.Equal(0, TempObjects.Count());
     }
 }
Example #42
0
        public void Delete()
        {
            using (Mapping<ObjectClass1> TestObject = new Mapping<ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
            {
                TestObject.Map(x => x.ID, "ID_")
                    .Map(x => x.StringValue, "StringValue_", 100)
                    .Map(x => x.FloatValue, "FloatValue_")
                    .Map(x => x.BoolValue, "BoolValue_")
                    .Map(x => x.LongValue, "LongValue_");
                ObjectClass1 TempObject = new ObjectClass1();
                TempObject.StringValue = "Test";
                TempObject.BoolValue = false;
                TempObject.FloatValue = 1.5f;
                TempObject.LongValue = 12;
                TestObject.Save<int>(TempObject);
                Assert.Equal(1, TestObject.Delete(TempObject));

                using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) AS ItemCount FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
                {
                    Helper.ExecuteReader();
                    if (Helper.Read())
                    {
                        Assert.Equal(0, Helper.GetParameter<int>("ItemCount", -1));
                    }
                    else
                    {
                        Assert.Fail("Nothing was inserted");
                    }
                }
            }
        }
        public void Connect()
        {
            Assert.DoesNotThrow<Exception>(() =>
            {
                using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
                {

                }
            });
        }
 public void UpdateDatabase()
 {
     Database Database = new Database("TestDatabase");
     Table TestTable = Database.AddTable("TestTable");
     TestTable.AddColumn<string>("ID_", DbType.Int32);
     TestTable.AddColumn<string>("Value1", DbType.String, 100);
     TestTable.AddColumn<string>("Value2", DbType.Double);
     Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     Database Database2 = new Database("TestDatabase");
     TestTable = Database2.AddTable("TestTable");
     TestTable.AddColumn<string>("ID_", DbType.Int32);
     TestTable.AddColumn<string>("Value1", DbType.String, 100);
     TestTable.AddColumn<string>("Value2", DbType.Double);
     TestTable.AddColumn<string>("Value3", DbType.Boolean);
     Utilities.SQL.SQLServer.SQLServer.UpdateDatabase(Database2, Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2,Value3) VALUES (@ID_,@Value1,@Value2,@Value3)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Helper.AddParameter<int>("@ID_", 1);
         Helper.AddParameter<string>("@Value1", "Test String");
         Helper.AddParameter<float>("@Value2", 3.0f);
         Helper.AddParameter<bool>("@Value3", true);
         Assert.Equal(1, Helper.ExecuteNonQuery());
     }
     Database Database3 = Utilities.SQL.SQLServer.SQLServer.GetDatabaseStructure("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     Assert.Equal(Database2.Tables.First().Name, Database3.Tables.First().Name);
     Assert.Equal(Database2.Tables.First().Columns.Count, Database3.Tables.First().Columns.Count);
     Assert.Equal(DbType.Int32, Database3.Tables.First().Columns.First(x => x.Name == "ID_").DataType);
     Assert.Equal(DbType.String, Database3.Tables.First().Columns.First(x => x.Name == "Value1").DataType);
     Assert.Equal(DbType.Double, Database3.Tables.First().Columns.First(x => x.Name == "Value2").DataType);
     Assert.Equal(100, Database3.Tables.First().Columns.First(x => x.Name == "Value1").Length);
     Assert.Equal(4, Database3.Tables.First().Columns.First(x => x.Name == "ID_").Length);
     Assert.Equal(8, Database3.Tables.First().Columns.First(x => x.Name == "Value2").Length);
 }
 public void Any()
 {
     Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
     Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_")
             .Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_");
     ObjectClass1 TempObject = new ObjectClass1();
     using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
     {
         TempObject.StringValue = "Test String";
         TempObject.BoolValue = true;
         TempObject.FloatValue = 1234.5f;
         TempObject.LongValue = 12345;
         ORM.Save<ObjectClass1,int>(TempObject);
         TempObject = null;
         TempObject = ORM.Any<ObjectClass1>();
         Assert.Equal("Test String", TempObject.StringValue);
         Assert.Equal(1234.5f, TempObject.FloatValue);
         Assert.Equal(true, TempObject.BoolValue);
         Assert.Equal(12345, TempObject.LongValue);
         Assert.Equal(1, TempObject.ID);
     }
 }
 public void Creation()
 {
     Assert.DoesNotThrow(() => { Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text); });
 }
 public void Any()
 {
     using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
     {
         Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
         TestObject.Map(x => x.ID, "ID_")
             .Map(x => x.StringValue, "StringValue_")
             .Map(x => x.FloatValue, "FloatValue_")
             .Map(x => x.BoolValue, "BoolValue_")
             .Map(x => x.LongValue, "LongValue_")
             .Map(x => x.StringMaxValue, "StringMaxValue_");
         Utilities.Random.Random Rand = new Utilities.Random.Random(12345);
         ObjectClass1 TempObject = new ObjectClass1();
         TempObject.StringValue = "Test String";
         TempObject.BoolValue = true;
         TempObject.FloatValue = 1234.5f;
         TempObject.LongValue = 12345;
         TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
         string StringMaxValue = TempObject.StringMaxValue;
         Helper2.Save<ObjectClass1, int>(TempObject);
         TempObject = Helper2.Any<ObjectClass1>();
         Assert.Equal("Test String", TempObject.StringValue);
         Assert.Equal(1234.5f, TempObject.FloatValue);
         Assert.Equal(true, TempObject.BoolValue);
         Assert.Equal(12345, TempObject.LongValue);
         Assert.Equal(1, TempObject.ID);
         Assert.Equal(StringMaxValue, TempObject.StringMaxValue);
     }
 }