text:
namespace GHTUtils {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;

    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class GHTTestSuiteResult : DataSet {

        private TestSuiteResultsDataTable tableTestSuiteResults;

        private TestSuiteInfoDataTable tableTestSuiteInfo;

        public GHTTestSuiteResult() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }

        protected GHTTestSuiteResult(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["TestSuiteResults"] != null)) {
                    this.Tables.Add(new TestSuiteResultsDataTable(ds.Tables["TestSuiteResults"]));
                }
                if ((ds.Tables["TestSuiteInfo"] != null)) {
                    this.Tables.Add(new TestSuiteInfoDataTable(ds.Tables["TestSuiteInfo"]));
                }
                this.DataSetName = ds.DataSetName;
                this.Prefix = ds.Prefix;
                this.Namespace = ds.Namespace;
                this.Locale = ds.Locale;
                this.CaseSensitive = ds.CaseSensitive;
                this.EnforceConstraints = ds.EnforceConstraints;
                this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
                this.InitVars();
            }
            else {
                this.InitClass();
            }
            this.GetSerializationData(info, context);
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public TestSuiteResultsDataTable TestSuiteResults {
            get {
                return this.tableTestSuiteResults;
            }
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public TestSuiteInfoDataTable TestSuiteInfo {
            get {
                return this.tableTestSuiteInfo;
            }
        }

        public override DataSet Clone() {
            GHTTestSuiteResult cln = ((GHTTestSuiteResult)(base.Clone()));
            cln.InitVars();
            return cln;
        }

        protected override bool ShouldSerializeTables() {
            return false;
        }

        protected override bool ShouldSerializeRelations() {
            return false;
        }

        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["TestSuiteResults"] != null)) {
                this.Tables.Add(new TestSuiteResultsDataTable(ds.Tables["TestSuiteResults"]));
            }
            if ((ds.Tables["TestSuiteInfo"] != null)) {
                this.Tables.Add(new TestSuiteInfoDataTable(ds.Tables["TestSuiteInfo"]));
            }
            this.DataSetName = ds.DataSetName;
            this.Prefix = ds.Prefix;
            this.Namespace = ds.Namespace;
            this.Locale = ds.Locale;
            this.CaseSensitive = ds.CaseSensitive;
            this.EnforceConstraints = ds.EnforceConstraints;
            this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
            this.InitVars();
        }

        protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(stream, null));
            stream.Position = 0;
            return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
        }

        internal void InitVars() {
            this.tableTestSuiteResults = ((TestSuiteResultsDataTable)(this.Tables["TestSuiteResults"]));
            if ((this.tableTestSuiteResults != null)) {
                this.tableTestSuiteResults.InitVars();
            }
            this.tableTestSuiteInfo = ((TestSuiteInfoDataTable)(this.Tables["TestSuiteInfo"]));
            if ((this.tableTestSuiteInfo != null)) {
                this.tableTestSuiteInfo.InitVars();
            }
        }

        private void InitClass() {
            this.DataSetName = "GHTTestSuiteResult";
            this.Prefix = "";
            this.Namespace = "http://www.mainsoft.com/GH/GHT/XMLSerializationTS/Result";
            this.Locale = new System.Globalization.CultureInfo("en-US");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.tableTestSuiteResults = new TestSuiteResultsDataTable();
            this.Tables.Add(this.tableTestSuiteResults);
            this.tableTestSuiteInfo = new TestSuiteInfoDataTable();
            this.Tables.Add(this.tableTestSuiteInfo);
        }

        private bool ShouldSerializeTestSuiteResults() {
            return false;
        }

        private bool ShouldSerializeTestSuiteInfo() {
            return false;
        }

        private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
            if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitVars();
            }
        }

        public delegate void TestSuiteResultsRowChangeEventHandler(object sender, TestSuiteResultsRowChangeEvent e);

        public delegate void TestSuiteInfoRowChangeEventHandler(object sender, TestSuiteInfoRowChangeEvent e);

        [System.Diagnostics.DebuggerStepThrough()]
        public class TestSuiteResultsDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnTestId;

            private DataColumn columnDescription;

            private DataColumn columnStatus;

            private DataColumn columnComment;

            private DataColumn columnStatusUrl;

            private DataColumn columnNetStatus;

            private DataColumn columnNetStatusUrl;

            private DataColumn columnNetMsg;

            private DataColumn columnNetExType;

            private DataColumn columnNetStack;

            private DataColumn columnNetInnerExType;

            private DataColumn columnNetInnerMsg;

            private DataColumn columnNetInnerstack;

            private DataColumn columnNetTestPhase;

            private DataColumn columnGHStatus;

            private DataColumn columnGHStatusUrl;

            private DataColumn columnGHExType;

            private DataColumn columnGHMsg;

            private DataColumn columnGHStack;

            private DataColumn columnGHInnerExType;

            private DataColumn columnGHInnerMsg;

            private DataColumn columnGHInnerStack;

            private DataColumn columnGHTestPhase;

            private DataColumn columnUserField1;

            private DataColumn columnUserField2;

            private DataColumn columnUserField3;

            internal TestSuiteResultsDataTable() :
                    base("TestSuiteResults") {
                this.InitClass();
            }

            internal TestSuiteResultsDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn TestIdColumn {
                get {
                    return this.columnTestId;
                }
            }

            internal DataColumn DescriptionColumn {
                get {
                    return this.columnDescription;
                }
            }

            internal DataColumn StatusColumn {
                get {
                    return this.columnStatus;
                }
            }

            internal DataColumn CommentColumn {
                get {
                    return this.columnComment;
                }
            }

            internal DataColumn StatusUrlColumn {
                get {
                    return this.columnStatusUrl;
                }
            }

            internal DataColumn NetStatusColumn {
                get {
                    return this.columnNetStatus;
                }
            }

            internal DataColumn NetStatusUrlColumn {
                get {
                    return this.columnNetStatusUrl;
                }
            }

            internal DataColumn NetMsgColumn {
                get {
                    return this.columnNetMsg;
                }
            }

            internal DataColumn NetExTypeColumn {
                get {
                    return this.columnNetExType;
                }
            }

            internal DataColumn NetStackColumn {
                get {
                    return this.columnNetStack;
                }
            }

            internal DataColumn NetInnerExTypeColumn {
                get {
                    return this.columnNetInnerExType;
                }
            }

            internal DataColumn NetInnerMsgColumn {
                get {
                    return this.columnNetInnerMsg;
                }
            }

            internal DataColumn NetInnerstackColumn {
                get {
                    return this.columnNetInnerstack;
                }
            }

            internal DataColumn NetTestPhaseColumn {
                get {
                    return this.columnNetTestPhase;
                }
            }

            internal DataColumn GHStatusColumn {
                get {
                    return this.columnGHStatus;
                }
            }

            internal DataColumn GHStatusUrlColumn {
                get {
                    return this.columnGHStatusUrl;
                }
            }

            internal DataColumn GHExTypeColumn {
                get {
                    return this.columnGHExType;
                }
            }

            internal DataColumn GHMsgColumn {
                get {
                    return this.columnGHMsg;
                }
            }

            internal DataColumn GHStackColumn {
                get {
                    return this.columnGHStack;
                }
            }

            internal DataColumn GHInnerExTypeColumn {
                get {
                    return this.columnGHInnerExType;
                }
            }

            internal DataColumn GHInnerMsgColumn {
                get {
                    return this.columnGHInnerMsg;
                }
            }

            internal DataColumn GHInnerStackColumn {
                get {
                    return this.columnGHInnerStack;
                }
            }

            internal DataColumn GHTestPhaseColumn {
                get {
                    return this.columnGHTestPhase;
                }
            }

            internal DataColumn UserField1Column {
                get {
                    return this.columnUserField1;
                }
            }

            internal DataColumn UserField2Column {
                get {
                    return this.columnUserField2;
                }
            }

            internal DataColumn UserField3Column {
                get {
                    return this.columnUserField3;
                }
            }

            public TestSuiteResultsRow this[int index] {
                get {
                    return ((TestSuiteResultsRow)(this.Rows[index]));
                }
            }

            public event TestSuiteResultsRowChangeEventHandler TestSuiteResultsRowChanged;

            public event TestSuiteResultsRowChangeEventHandler TestSuiteResultsRowChanging;

            public event TestSuiteResultsRowChangeEventHandler TestSuiteResultsRowDeleted;

            public event TestSuiteResultsRowChangeEventHandler TestSuiteResultsRowDeleting;

            public void AddTestSuiteResultsRow(TestSuiteResultsRow row) {
                this.Rows.Add(row);
            }

            public TestSuiteResultsRow AddTestSuiteResultsRow(
                        string TestId,
                        string Description,
                        string Status,
                        string Comment,
                        string StatusUrl,
                        string NetStatus,
                        string NetStatusUrl,
                        string NetMsg,
                        string NetExType,
                        string NetStack,
                        string NetInnerExType,
                        string NetInnerMsg,
                        string NetInnerstack,
                        string NetTestPhase,
                        string GHStatus,
                        string GHStatusUrl,
                        string GHExType,
                        string GHMsg,
                        string GHStack,
                        string GHInnerExType,
                        string GHInnerMsg,
                        string GHInnerStack,
                        string GHTestPhase,
                        string UserField1,
                        string UserField2,
                        string UserField3) {
                TestSuiteResultsRow rowTestSuiteResultsRow = ((TestSuiteResultsRow)(this.NewRow()));
                rowTestSuiteResultsRow.ItemArray = new object[] {
                        TestId,
                        Description,
                        Status,
                        Comment,
                        StatusUrl,
                        NetStatus,
                        NetStatusUrl,
                        NetMsg,
                        NetExType,
                        NetStack,
                        NetInnerExType,
                        NetInnerMsg,
                        NetInnerstack,
                        NetTestPhase,
                        GHStatus,
                        GHStatusUrl,
                        GHExType,
                        GHMsg,
                        GHStack,
                        GHInnerExType,
                        GHInnerMsg,
                        GHInnerStack,
                        GHTestPhase,
                        UserField1,
                        UserField2,
                        UserField3};
                this.Rows.Add(rowTestSuiteResultsRow);
                return rowTestSuiteResultsRow;
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                TestSuiteResultsDataTable cln = ((TestSuiteResultsDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new TestSuiteResultsDataTable();
            }

            internal void InitVars() {
                this.columnTestId = this.Columns["TestId"];
                this.columnDescription = this.Columns["Description"];
                this.columnStatus = this.Columns["Status"];
                this.columnComment = this.Columns["Comment"];
                this.columnStatusUrl = this.Columns["StatusUrl"];
                this.columnNetStatus = this.Columns["NetStatus"];
                this.columnNetStatusUrl = this.Columns["NetStatusUrl"];
                this.columnNetMsg = this.Columns["NetMsg"];
                this.columnNetExType = this.Columns["NetExType"];
                this.columnNetStack = this.Columns["NetStack"];
                this.columnNetInnerExType = this.Columns["NetInnerExType"];
                this.columnNetInnerMsg = this.Columns["NetInnerMsg"];
                this.columnNetInnerstack = this.Columns["NetInnerstack"];
                this.columnNetTestPhase = this.Columns["NetTestPhase"];
                this.columnGHStatus = this.Columns["GHStatus"];
                this.columnGHStatusUrl = this.Columns["GHStatusUrl"];
                this.columnGHExType = this.Columns["GHExType"];
                this.columnGHMsg = this.Columns["GHMsg"];
                this.columnGHStack = this.Columns["GHStack"];
                this.columnGHInnerExType = this.Columns["GHInnerExType"];
                this.columnGHInnerMsg = this.Columns["GHInnerMsg"];
                this.columnGHInnerStack = this.Columns["GHInnerStack"];
                this.columnGHTestPhase = this.Columns["GHTestPhase"];
                this.columnUserField1 = this.Columns["UserField1"];
                this.columnUserField2 = this.Columns["UserField2"];
                this.columnUserField3 = this.Columns["UserField3"];
            }

            private void InitClass() {
                this.columnTestId = new DataColumn("TestId", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnTestId);
                this.columnDescription = new DataColumn("Description", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDescription);
                this.columnStatus = new DataColumn("Status", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnStatus);
                this.columnComment = new DataColumn("Comment", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnComment);
                this.columnStatusUrl = new DataColumn("StatusUrl", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnStatusUrl);
                this.columnNetStatus = new DataColumn("NetStatus", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetStatus);
                this.columnNetStatusUrl = new DataColumn("NetStatusUrl", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetStatusUrl);
                this.columnNetMsg = new DataColumn("NetMsg", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetMsg);
                this.columnNetExType = new DataColumn("NetExType", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetExType);
                this.columnNetStack = new DataColumn("NetStack", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetStack);
                this.columnNetInnerExType = new DataColumn("NetInnerExType", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetInnerExType);
                this.columnNetInnerMsg = new DataColumn("NetInnerMsg", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetInnerMsg);
                this.columnNetInnerstack = new DataColumn("NetInnerstack", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetInnerstack);
                this.columnNetTestPhase = new DataColumn("NetTestPhase", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNetTestPhase);
                this.columnGHStatus = new DataColumn("GHStatus", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHStatus);
                this.columnGHStatusUrl = new DataColumn("GHStatusUrl", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHStatusUrl);
                this.columnGHExType = new DataColumn("GHExType", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHExType);
                this.columnGHMsg = new DataColumn("GHMsg", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHMsg);
                this.columnGHStack = new DataColumn("GHStack", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHStack);
                this.columnGHInnerExType = new DataColumn("GHInnerExType", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHInnerExType);
                this.columnGHInnerMsg = new DataColumn("GHInnerMsg", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHInnerMsg);
                this.columnGHInnerStack = new DataColumn("GHInnerStack", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHInnerStack);
                this.columnGHTestPhase = new DataColumn("GHTestPhase", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnGHTestPhase);
                this.columnUserField1 = new DataColumn("UserField1", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnUserField1);
                this.columnUserField2 = new DataColumn("UserField2", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnUserField2);
                this.columnUserField3 = new DataColumn("UserField3", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnUserField3);
                this.columnTestId.AllowDBNull = false;
                this.columnStatus.AllowDBNull = false;
            }

            public TestSuiteResultsRow NewTestSuiteResultsRow() {
                return ((TestSuiteResultsRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new TestSuiteResultsRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(TestSuiteResultsRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.TestSuiteResultsRowChanged != null)) {
                    this.TestSuiteResultsRowChanged(this, new TestSuiteResultsRowChangeEvent(((TestSuiteResultsRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.TestSuiteResultsRowChanging != null)) {
                    this.TestSuiteResultsRowChanging(this, new TestSuiteResultsRowChangeEvent(((TestSuiteResultsRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.TestSuiteResultsRowDeleted != null)) {
                    this.TestSuiteResultsRowDeleted(this, new TestSuiteResultsRowChangeEvent(((TestSuiteResultsRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.TestSuiteResultsRowDeleting != null)) {
                    this.TestSuiteResultsRowDeleting(this, new TestSuiteResultsRowChangeEvent(((TestSuiteResultsRow)(e.Row)), e.Action));
                }
            }

            public void RemoveTestSuiteResultsRow(TestSuiteResultsRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class TestSuiteResultsRow : DataRow {

            private TestSuiteResultsDataTable tableTestSuiteResults;

            internal TestSuiteResultsRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableTestSuiteResults = ((TestSuiteResultsDataTable)(this.Table));
            }

            public string TestId {
                get {
                    return ((string)(this[this.tableTestSuiteResults.TestIdColumn]));
                }
                set {
                    this[this.tableTestSuiteResults.TestIdColumn] = value;
                }
            }

            public string Description {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.DescriptionColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.DescriptionColumn] = value;
                }
            }

            public string Status {
                get {
                    return ((string)(this[this.tableTestSuiteResults.StatusColumn]));
                }
                set {
                    this[this.tableTestSuiteResults.StatusColumn] = value;
                }
            }

            public string Comment {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.CommentColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.CommentColumn] = value;
                }
            }

            public string StatusUrl {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.StatusUrlColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.StatusUrlColumn] = value;
                }
            }

            public string NetStatus {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetStatusColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetStatusColumn] = value;
                }
            }

            public string NetStatusUrl {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetStatusUrlColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetStatusUrlColumn] = value;
                }
            }

            public string NetMsg {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetMsgColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetMsgColumn] = value;
                }
            }

            public string NetExType {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetExTypeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetExTypeColumn] = value;
                }
            }

            public string NetStack {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetStackColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetStackColumn] = value;
                }
            }

            public string NetInnerExType {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetInnerExTypeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetInnerExTypeColumn] = value;
                }
            }

            public string NetInnerMsg {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetInnerMsgColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetInnerMsgColumn] = value;
                }
            }

            public string NetInnerstack {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetInnerstackColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetInnerstackColumn] = value;
                }
            }

            public string NetTestPhase {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.NetTestPhaseColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.NetTestPhaseColumn] = value;
                }
            }

            public string GHStatus {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHStatusColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHStatusColumn] = value;
                }
            }

            public string GHStatusUrl {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHStatusUrlColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHStatusUrlColumn] = value;
                }
            }

            public string GHExType {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHExTypeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHExTypeColumn] = value;
                }
            }

            public string GHMsg {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHMsgColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHMsgColumn] = value;
                }
            }

            public string GHStack {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHStackColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHStackColumn] = value;
                }
            }

            public string GHInnerExType {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHInnerExTypeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHInnerExTypeColumn] = value;
                }
            }

            public string GHInnerMsg {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHInnerMsgColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHInnerMsgColumn] = value;
                }
            }

            public string GHInnerStack {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHInnerStackColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHInnerStackColumn] = value;
                }
            }

            public string GHTestPhase {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.GHTestPhaseColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.GHTestPhaseColumn] = value;
                }
            }

            public string UserField1 {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.UserField1Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.UserField1Column] = value;
                }
            }

            public string UserField2 {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.UserField2Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.UserField2Column] = value;
                }
            }

            public string UserField3 {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteResults.UserField3Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteResults.UserField3Column] = value;
                }
            }

            public bool IsDescriptionNull() {
                return this.IsNull(this.tableTestSuiteResults.DescriptionColumn);
            }

            public void SetDescriptionNull() {
                this[this.tableTestSuiteResults.DescriptionColumn] = System.Convert.DBNull;
            }

            public bool IsCommentNull() {
                return this.IsNull(this.tableTestSuiteResults.CommentColumn);
            }

            public void SetCommentNull() {
                this[this.tableTestSuiteResults.CommentColumn] = System.Convert.DBNull;
            }

            public bool IsStatusUrlNull() {
                return this.IsNull(this.tableTestSuiteResults.StatusUrlColumn);
            }

            public void SetStatusUrlNull() {
                this[this.tableTestSuiteResults.StatusUrlColumn] = System.Convert.DBNull;
            }

            public bool IsNetStatusNull() {
                return this.IsNull(this.tableTestSuiteResults.NetStatusColumn);
            }

            public void SetNetStatusNull() {
                this[this.tableTestSuiteResults.NetStatusColumn] = System.Convert.DBNull;
            }

            public bool IsNetStatusUrlNull() {
                return this.IsNull(this.tableTestSuiteResults.NetStatusUrlColumn);
            }

            public void SetNetStatusUrlNull() {
                this[this.tableTestSuiteResults.NetStatusUrlColumn] = System.Convert.DBNull;
            }

            public bool IsNetMsgNull() {
                return this.IsNull(this.tableTestSuiteResults.NetMsgColumn);
            }

            public void SetNetMsgNull() {
                this[this.tableTestSuiteResults.NetMsgColumn] = System.Convert.DBNull;
            }

            public bool IsNetExTypeNull() {
                return this.IsNull(this.tableTestSuiteResults.NetExTypeColumn);
            }

            public void SetNetExTypeNull() {
                this[this.tableTestSuiteResults.NetExTypeColumn] = System.Convert.DBNull;
            }

            public bool IsNetStackNull() {
                return this.IsNull(this.tableTestSuiteResults.NetStackColumn);
            }

            public void SetNetStackNull() {
                this[this.tableTestSuiteResults.NetStackColumn] = System.Convert.DBNull;
            }

            public bool IsNetInnerExTypeNull() {
                return this.IsNull(this.tableTestSuiteResults.NetInnerExTypeColumn);
            }

            public void SetNetInnerExTypeNull() {
                this[this.tableTestSuiteResults.NetInnerExTypeColumn] = System.Convert.DBNull;
            }

            public bool IsNetInnerMsgNull() {
                return this.IsNull(this.tableTestSuiteResults.NetInnerMsgColumn);
            }

            public void SetNetInnerMsgNull() {
                this[this.tableTestSuiteResults.NetInnerMsgColumn] = System.Convert.DBNull;
            }

            public bool IsNetInnerstackNull() {
                return this.IsNull(this.tableTestSuiteResults.NetInnerstackColumn);
            }

            public void SetNetInnerstackNull() {
                this[this.tableTestSuiteResults.NetInnerstackColumn] = System.Convert.DBNull;
            }

            public bool IsNetTestPhaseNull() {
                return this.IsNull(this.tableTestSuiteResults.NetTestPhaseColumn);
            }

            public void SetNetTestPhaseNull() {
                this[this.tableTestSuiteResults.NetTestPhaseColumn] = System.Convert.DBNull;
            }

            public bool IsGHStatusNull() {
                return this.IsNull(this.tableTestSuiteResults.GHStatusColumn);
            }

            public void SetGHStatusNull() {
                this[this.tableTestSuiteResults.GHStatusColumn] = System.Convert.DBNull;
            }

            public bool IsGHStatusUrlNull() {
                return this.IsNull(this.tableTestSuiteResults.GHStatusUrlColumn);
            }

            public void SetGHStatusUrlNull() {
                this[this.tableTestSuiteResults.GHStatusUrlColumn] = System.Convert.DBNull;
            }

            public bool IsGHExTypeNull() {
                return this.IsNull(this.tableTestSuiteResults.GHExTypeColumn);
            }

            public void SetGHExTypeNull() {
                this[this.tableTestSuiteResults.GHExTypeColumn] = System.Convert.DBNull;
            }

            public bool IsGHMsgNull() {
                return this.IsNull(this.tableTestSuiteResults.GHMsgColumn);
            }

            public void SetGHMsgNull() {
                this[this.tableTestSuiteResults.GHMsgColumn] = System.Convert.DBNull;
            }

            public bool IsGHStackNull() {
                return this.IsNull(this.tableTestSuiteResults.GHStackColumn);
            }

            public void SetGHStackNull() {
                this[this.tableTestSuiteResults.GHStackColumn] = System.Convert.DBNull;
            }

            public bool IsGHInnerExTypeNull() {
                return this.IsNull(this.tableTestSuiteResults.GHInnerExTypeColumn);
            }

            public void SetGHInnerExTypeNull() {
                this[this.tableTestSuiteResults.GHInnerExTypeColumn] = System.Convert.DBNull;
            }

            public bool IsGHInnerMsgNull() {
                return this.IsNull(this.tableTestSuiteResults.GHInnerMsgColumn);
            }

            public void SetGHInnerMsgNull() {
                this[this.tableTestSuiteResults.GHInnerMsgColumn] = System.Convert.DBNull;
            }

            public bool IsGHInnerStackNull() {
                return this.IsNull(this.tableTestSuiteResults.GHInnerStackColumn);
            }

            public void SetGHInnerStackNull() {
                this[this.tableTestSuiteResults.GHInnerStackColumn] = System.Convert.DBNull;
            }

            public bool IsGHTestPhaseNull() {
                return this.IsNull(this.tableTestSuiteResults.GHTestPhaseColumn);
            }

            public void SetGHTestPhaseNull() {
                this[this.tableTestSuiteResults.GHTestPhaseColumn] = System.Convert.DBNull;
            }

            public bool IsUserField1Null() {
                return this.IsNull(this.tableTestSuiteResults.UserField1Column);
            }

            public void SetUserField1Null() {
                this[this.tableTestSuiteResults.UserField1Column] = System.Convert.DBNull;
            }

            public bool IsUserField2Null() {
                return this.IsNull(this.tableTestSuiteResults.UserField2Column);
            }

            public void SetUserField2Null() {
                this[this.tableTestSuiteResults.UserField2Column] = System.Convert.DBNull;
            }

            public bool IsUserField3Null() {
                return this.IsNull(this.tableTestSuiteResults.UserField3Column);
            }

            public void SetUserField3Null() {
                this[this.tableTestSuiteResults.UserField3Column] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class TestSuiteResultsRowChangeEvent : EventArgs {

            private TestSuiteResultsRow eventRow;

            private DataRowAction eventAction;

            public TestSuiteResultsRowChangeEvent(TestSuiteResultsRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public TestSuiteResultsRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class TestSuiteInfoDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnName;

            private DataColumn columnBuild;

            private DataColumn columnDescription;

            private DataColumn columnRunDate;

            private DataColumn columnRunBy;

            private DataColumn columnIsComparative;

            private DataColumn columnFileName;

            internal TestSuiteInfoDataTable() :
                    base("TestSuiteInfo") {
                this.InitClass();
            }

            internal TestSuiteInfoDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn NameColumn {
                get {
                    return this.columnName;
                }
            }

            internal DataColumn BuildColumn {
                get {
                    return this.columnBuild;
                }
            }

            internal DataColumn DescriptionColumn {
                get {
                    return this.columnDescription;
                }
            }

            internal DataColumn RunDateColumn {
                get {
                    return this.columnRunDate;
                }
            }

            internal DataColumn RunByColumn {
                get {
                    return this.columnRunBy;
                }
            }

            internal DataColumn IsComparativeColumn {
                get {
                    return this.columnIsComparative;
                }
            }

            internal DataColumn FileNameColumn {
                get {
                    return this.columnFileName;
                }
            }

            public TestSuiteInfoRow this[int index] {
                get {
                    return ((TestSuiteInfoRow)(this.Rows[index]));
                }
            }

            public event TestSuiteInfoRowChangeEventHandler TestSuiteInfoRowChanged;

            public event TestSuiteInfoRowChangeEventHandler TestSuiteInfoRowChanging;

            public event TestSuiteInfoRowChangeEventHandler TestSuiteInfoRowDeleted;

            public event TestSuiteInfoRowChangeEventHandler TestSuiteInfoRowDeleting;

            public void AddTestSuiteInfoRow(TestSuiteInfoRow row) {
                this.Rows.Add(row);
            }

            public TestSuiteInfoRow AddTestSuiteInfoRow(string Name, string Build, string Description, string RunDate, string RunBy, bool IsComparative, string FileName) {
                TestSuiteInfoRow rowTestSuiteInfoRow = ((TestSuiteInfoRow)(this.NewRow()));
                rowTestSuiteInfoRow.ItemArray = new object[] {
                        Name,
                        Build,
                        Description,
                        RunDate,
                        RunBy,
                        IsComparative,
                        FileName};
                this.Rows.Add(rowTestSuiteInfoRow);
                return rowTestSuiteInfoRow;
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                TestSuiteInfoDataTable cln = ((TestSuiteInfoDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new TestSuiteInfoDataTable();
            }

            internal void InitVars() {
                this.columnName = this.Columns["Name"];
                this.columnBuild = this.Columns["Build"];
                this.columnDescription = this.Columns["Description"];
                this.columnRunDate = this.Columns["RunDate"];
                this.columnRunBy = this.Columns["RunBy"];
                this.columnIsComparative = this.Columns["IsComparative"];
                this.columnFileName = this.Columns["FileName"];
            }

            private void InitClass() {
                this.columnName = new DataColumn("Name", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnName);
                this.columnBuild = new DataColumn("Build", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnBuild);
                this.columnDescription = new DataColumn("Description", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDescription);
                this.columnRunDate = new DataColumn("RunDate", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnRunDate);
                this.columnRunBy = new DataColumn("RunBy", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnRunBy);
                this.columnIsComparative = new DataColumn("IsComparative", typeof(bool), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIsComparative);
                this.columnFileName = new DataColumn("FileName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnFileName);
            }

            public TestSuiteInfoRow NewTestSuiteInfoRow() {
                return ((TestSuiteInfoRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new TestSuiteInfoRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(TestSuiteInfoRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.TestSuiteInfoRowChanged != null)) {
                    this.TestSuiteInfoRowChanged(this, new TestSuiteInfoRowChangeEvent(((TestSuiteInfoRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.TestSuiteInfoRowChanging != null)) {
                    this.TestSuiteInfoRowChanging(this, new TestSuiteInfoRowChangeEvent(((TestSuiteInfoRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.TestSuiteInfoRowDeleted != null)) {
                    this.TestSuiteInfoRowDeleted(this, new TestSuiteInfoRowChangeEvent(((TestSuiteInfoRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.TestSuiteInfoRowDeleting != null)) {
                    this.TestSuiteInfoRowDeleting(this, new TestSuiteInfoRowChangeEvent(((TestSuiteInfoRow)(e.Row)), e.Action));
                }
            }

            public void RemoveTestSuiteInfoRow(TestSuiteInfoRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class TestSuiteInfoRow : DataRow {

            private TestSuiteInfoDataTable tableTestSuiteInfo;

            internal TestSuiteInfoRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableTestSuiteInfo = ((TestSuiteInfoDataTable)(this.Table));
            }

            public string Name {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteInfo.NameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.NameColumn] = value;
                }
            }

            public string Build {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteInfo.BuildColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.BuildColumn] = value;
                }
            }

            public string Description {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteInfo.DescriptionColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.DescriptionColumn] = value;
                }
            }

            public string RunDate {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteInfo.RunDateColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.RunDateColumn] = value;
                }
            }

            public string RunBy {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteInfo.RunByColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.RunByColumn] = value;
                }
            }

            public bool IsComparative {
                get {
                    try {
                        return ((bool)(this[this.tableTestSuiteInfo.IsComparativeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.IsComparativeColumn] = value;
                }
            }

            public string FileName {
                get {
                    try {
                        return ((string)(this[this.tableTestSuiteInfo.FileNameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableTestSuiteInfo.FileNameColumn] = value;
                }
            }

            public bool IsNameNull() {
                return this.IsNull(this.tableTestSuiteInfo.NameColumn);
            }

            public void SetNameNull() {
                this[this.tableTestSuiteInfo.NameColumn] = System.Convert.DBNull;
            }

            public bool IsBuildNull() {
                return this.IsNull(this.tableTestSuiteInfo.BuildColumn);
            }

            public void SetBuildNull() {
                this[this.tableTestSuiteInfo.BuildColumn] = System.Convert.DBNull;
            }

            public bool IsDescriptionNull() {
                return this.IsNull(this.tableTestSuiteInfo.DescriptionColumn);
            }

            public void SetDescriptionNull() {
                this[this.tableTestSuiteInfo.DescriptionColumn] = System.Convert.DBNull;
            }

            public bool IsRunDateNull() {
                return this.IsNull(this.tableTestSuiteInfo.RunDateColumn);
            }

            public void SetRunDateNull() {
                this[this.tableTestSuiteInfo.RunDateColumn] = System.Convert.DBNull;
            }

            public bool IsRunByNull() {
                return this.IsNull(this.tableTestSuiteInfo.RunByColumn);
            }

            public void SetRunByNull() {
                this[this.tableTestSuiteInfo.RunByColumn] = System.Convert.DBNull;
            }

            public bool IsIsComparativeNull() {
                return this.IsNull(this.tableTestSuiteInfo.IsComparativeColumn);
            }

            public void SetIsComparativeNull() {
                this[this.tableTestSuiteInfo.IsComparativeColumn] = System.Convert.DBNull;
            }

            public bool IsFileNameNull() {
                return this.IsNull(this.tableTestSuiteInfo.FileNameColumn);
            }

            public void SetFileNameNull() {
                this[this.tableTestSuiteInfo.FileNameColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class TestSuiteInfoRowChangeEvent : EventArgs {

            private TestSuiteInfoRow eventRow;

            private DataRowAction eventAction;

            public TestSuiteInfoRowChangeEvent(TestSuiteInfoRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public TestSuiteInfoRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.apache.flink.graph.drivers;

import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.api.java.typeutils.TupleTypeInfo;
import org.apache.flink.api.java.typeutils.ValueTypeInfo;
import org.apache.flink.graph.Edge;
import org.apache.flink.graph.Graph;
import org.apache.flink.graph.utils.EdgeToTuple2Map;
import org.apache.flink.types.NullValue;

/**
 * Convert a {@link Graph} to the {@link DataSet} of {@link Edge}.
 *
 * @param <K> graph ID type
 * @param <VV> vertex value type
 * @param <EV> edge value type
 */
public class EdgeList<K, VV, EV>
extends DriverBase<K, VV, EV> {

	@Override
	public String getShortDescription() {
		return "the edge list";
	}

	@Override
	public String getLongDescription() {
		return "Pass-through of the graph's edge list.";
	}

	@Override
	public DataSet plan(Graph<K, VV, EV> graph) throws Exception {
		DataSet<Edge<K, EV>> edges = graph.getEdges();

		if (hasNullValueEdges(edges)) {
			return edges
				.map(new EdgeToTuple2Map<>())
				.name("Edge to Tuple2")
				.setParallelism(parallelism.getValue().intValue());
		} else {
			return edges;
		}
	}

	/**
	 * Check whether the edge type of the {@link DataSet} is {@link NullValue}.
	 *
	 * @param edges data set for introspection
	 * @param <T> graph ID type
	 * @param <ET> edge value type
	 * @return whether the edge type of the {@link DataSet} is {@link NullValue}
	 */
	private static <T, ET> boolean hasNullValueEdges(DataSet<Edge<T, ET>> edges) {
		TypeInformation<?> genericTypeInfo = edges.getType();
		@SuppressWarnings("unchecked")
		TupleTypeInfo<Tuple3<T, T, ET>> tupleTypeInfo = (TupleTypeInfo<Tuple3<T, T, ET>>) genericTypeInfo;

		return tupleTypeInfo.getTypeAt(2).equals(ValueTypeInfo.NULL_VALUE_TYPE_INFO);
	}
}


text:
using System;

namespace Zeptomoby.OrbitTools
{
	/// <summary>
	/// Encapsulates a Julian date.
	/// </summary>
   public class Julian
   {
      private const double EPOCH_JAN0_12H_1900 = 2415020.0; // Dec 31.5 1899 = Dec 31 1899 12h UTC
      private const double EPOCH_JAN1_00H_1900 = 2415020.5; // Jan  1.0 1900 = Jan  1 1900 00h UTC
      private const double EPOCH_JAN1_12H_1900 = 2415021.0; // Jan  1.5 1900 = Jan  1 1900 12h UTC
      private const double EPOCH_JAN1_12H_2000 = 2451545.0; // Jan  1.5 2000 = Jan  1 2000 12h UTC

      private double m_Date; // Julian date
      private int    m_Year; // Year including century
      private double m_Day;  // Day of year, 1.0 = Jan 1 00h

      #region Construction

      /// <summary>
      /// Create a Julian date object from a DateTime object. The time
      /// contained in the DateTime object is assumed to be UTC.
      /// </summary>
      /// <param name="utc">The UTC time to convert.</param>
      public Julian(DateTime utc)
      {
         double day = utc.DayOfYear +
            (utc.Hour +
            ((utc.Minute +
            ((utc.Second + (utc.Millisecond / 1000.0)) / 60.0)) / 60.0)) / 24.0;

         Initialize(utc.Year, day);
      }

      /// <summary>
      /// Create a Julian date object given a year and day-of-year.
      /// </summary>
      /// <param name="year">The year, including the century (i.e., 2012).</param>
      /// <param name="doy">Day of year (1 means January 1, etc.).</param>
      /// <remarks>
      /// The fractional part of the day value is the fractional portion of
      /// the day.
      /// Examples:
      ///    day = 1.0  Jan 1 00h
      ///    day = 1.5  Jan 1 12h
      ///    day = 2.0  Jan 2 00h
      /// </remarks>
      public Julian(int year, double doy)
      {
         Initialize(year, doy);
      }

      #endregion

      #region Properties

      public double Date { get { return m_Date; } }

      public double FromJan0_12h_1900() { return m_Date - EPOCH_JAN0_12H_1900; }
      public double FromJan1_00h_1900() { return m_Date - EPOCH_JAN1_00H_1900; }
      public double FromJan1_12h_1900() { return m_Date - EPOCH_JAN1_12H_1900; }
      public double FromJan1_12h_2000() { return m_Date - EPOCH_JAN1_12H_2000; }

      #endregion

      /// <summary>
      /// Calculates the time difference between two Julian dates.
      /// </summary>
      /// <param name="date">Julian date.</param>
      /// <returns>
      /// A TimeSpan representing the time difference between the two dates.
      /// </returns>
      public TimeSpan Diff(Julian date)
      {
         const double TICKS_PER_DAY = 8.64e11; // 1 tick = 100 nanoseconds
         return new TimeSpan((long)((m_Date - date.m_Date) * TICKS_PER_DAY));
      }

      /// <summary>
      /// Initialize the Julian date object.
      /// </summary>
      /// <param name="year">The year, including the century.</param>
      /// <param name="doy">Day of year (1 means January 1, etc.)</param>
      /// <remarks>
      /// The first day of the year, Jan 1, is day 1.0. Noon on Jan 1 is
      /// represented by the day value of 1.5, etc.
      /// </remarks>
      protected void Initialize(int year, double doy)
      {
         // Arbitrary years used for error checking
         if (year < 1900 || year > 2100)
         {
            throw new ArgumentOutOfRangeException("year");
         }

         // The last day of a leap year is day 366
         if (doy < 1.0 || doy >= 367.0)
         {
            throw new ArgumentOutOfRangeException("doy");
         }

         m_Year = year;
         m_Day  = doy;

         // Now calculate Julian date
         // Ref: "Astronomical Formulae for Calculators", Jean Meeus, pages 23-25

         year--;

         // Centuries are not leap years unless they divide by 400
         int A = (year / 100);
         int B = 2 - A + (A / 4);

         double NewYears = (int)(365.25 * year) +
                           (int)(30.6001 * 14)  +
                           1720994.5 + B;

         m_Date = NewYears + doy;
      }

      /// <summary>
      /// Calculate Greenwich Mean Sidereal Time for the Julian date.
      /// </summary>
      /// <returns>
      /// The angle, in radians, measuring eastward from the Vernal Equinox to
      /// the prime meridian. This angle is also referred to as "ThetaG"
      /// (Theta GMST).
      /// </returns>
      public double ToGmst()
      {
         // References:
         //    The 1992 Astronomical Almanac, page B6.
         //    Explanatory Supplement to the Astronomical Almanac, page 50.
         //    Orbital Coordinate Systems, Part III, Dr. T.S. Kelso,
         //       Satellite Times, Nov/Dec 1995

         double UT = (m_Date + 0.5) % 1.0;
         double TU = (FromJan1_12h_2000() - UT) / 36525.0;

         double GMST = 24110.54841 + TU *
                       (8640184.812866 + TU * (0.093104 - TU * 6.2e-06));

         GMST = (GMST + Globals.SecPerDay * Globals.OmegaE * UT) % Globals.SecPerDay;

         if (GMST < 0.0)
         {
            GMST += Globals.SecPerDay;  // "wrap" negative modulo value
         }

         return  (Globals.TwoPi * (GMST / Globals.SecPerDay));
      }

      /// <summary>
      /// Calculate Local Mean Sidereal Time for this Julian date at the given
      /// longitude.
      /// </summary>
      /// <param name="lon">The longitude, in radians, measured west from Greenwich.</param>
      /// <returns>
      /// The angle, in radians, measuring eastward from the Vernal Equinox to
      /// the given longitude.
      /// </returns>
      public double ToLmst(double lon)
      {
         return (ToGmst() + lon) % Globals.TwoPi;
      }

      /// <summary>
      /// Returns a UTC DateTime object that corresponds to this Julian date.
      /// </summary>
      /// <returns>A DateTime object in UTC.</returns>
      public DateTime ToTime()
      {
         // Jan 1
         DateTime dt = new DateTime(m_Year, 1, 1);

         // m_Day = 1 = Jan1
         dt = dt.AddDays(m_Day - 1.0);

         return dt;
      }
   }
}


text:
/**
 * @overview
 *
 */

/**
 * Abstract class
 * @class
 * This class is a base class for briefcase item classes.
 *
 * @param {int}			id			the unique id
 * @param {ZmList}		list		a list that contains this item
 * @param {Boolean}		noCache		if true, do not cache this item

 * @extends		ZmItem
 *
 * @see		ZmBriefcaseBaseItem
 */
ZmBriefcaseBaseItem = function(id, list, noCache, type) {

	if (arguments.length == 0) { return; }
	ZmItem.call(this, type, id, list, noCache);
};

ZmBriefcaseBaseItem.prototype = new ZmItem;
ZmBriefcaseBaseItem.prototype.constructor = ZmBriefcaseBaseItem;

//Public methods

/**
 * Gets the path.
 *
 * @param	{Boolean}	dontIncludeThisName		if true, do not include this item name in the path
 * @return	{String}	the path
 */
ZmBriefcaseBaseItem.prototype.getPath =
function(dontIncludeThisName) {
	var briefcase = appCtxt.getById(this.folderId);
	var name = !dontIncludeThisName ? this.name : "";
	return [briefcase.getPath(), "/", name].join("");
};

/**
 * Gets the REST URL.
 *
 * @param	{Boolean}	dontIncludeThisName		if true, do not include this item name in the path
 * @param	{Boolean}	ignoreCustomDocs		if true, ignore custom docs
 * @param   {Boolean}   includeVersion			if true include the version if exists (it's latest for the base item)
 * @return	{String}	the REST URL
 */
ZmBriefcaseBaseItem.prototype.getRestUrl =
function(dontIncludeThisName, ignoreCustomDocs, includeVersion) {
	var url = ZmItem.prototype.getRestUrl.call(this);
	if (dontIncludeThisName) {
		url = url.replace(/[^\/]+$/,"");
	}
	if (includeVersion && this.version){
		url = url + (url.match(/\?/) ? '&' : '?' ) + "ver=" + this.version;
	}

	return url;
};

/**
 * Checks if this item is a real file.
 *
 * @return	{Boolean}	true if this item is a real file (not a web doc or folder)
 */
ZmBriefcaseBaseItem.prototype.isRealFile =
function() {
    return (!this.isFolder && !this.isWebDoc());
};

/**
 * Checks if this item is a web doc.
 *
 * @return	{Boolean}	true if this item is a web doc
 */
ZmBriefcaseBaseItem.prototype.isWebDoc =
function() {
    return (this.contentType == ZmMimeTable.APP_ZIMBRA_SLIDES || this.contentType == ZmMimeTable.APP_ZIMBRA_SPREADSHEET || this.contentType == ZmMimeTable.APP_ZIMBRA_DOC);
};

/**
 * Checks if this item is an document which can only be downloaded and cannot be rendered by browser
 *
 * @return	{Boolean}	true if this item is downloadable
 */
ZmBriefcaseBaseItem.prototype.isDownloadable =
function() {
    return (!this.isWebDoc() && !ZmMimeTable.isRenderable(this.contentType) && !ZmMimeTable.isRenderableImage(this.contentType) && !ZmMimeTable.isTextType(this.contentType));
};

/**
 * Checks if this item is a slide doc.
 *
 * @return	{Boolean}	true if this item is a slide doc
 */
ZmBriefcaseBaseItem.prototype.isSlideDoc =
function() {
    return (this.contentType == ZmMimeTable.APP_ZIMBRA_SLIDES);
};

/**
 * Gets the content type.
 *
 * @return	{String}	the content type
 */
ZmBriefcaseBaseItem.prototype.getContentType =
function() {
    return this.contentType;
};

/**
 * Gets the icon.
 *
 * @param	{Boolean}	large		if true, return the large icon
 * @return	{String}	the icon
 */
ZmBriefcaseBaseItem.prototype.getIcon =
function(large) {

	if (this.isFolder) {
		return "Folder";
	}

	var ct = this.contentType, icon;
	if (ct && ct.match(/;/)) {
		ct = ct.split(";")[0];
	}
	var mimeInfo = ct ? ZmMimeTable.getInfo(ct) : null;
	if (large) {
		icon = mimeInfo ? mimeInfo.imageLarge : "UnknownDoc_48";
	} else {
		icon = mimeInfo ? mimeInfo.image : "UnknownDoc" ;
	}

	return icon;
};

/**
 * Checks if this item is read only.
 *
 * @return	{Boolean}	true if this item is read only
 */
ZmBriefcaseBaseItem.prototype.isReadOnly =
function() {
	// if one of the ancestor is readonly then no chances of childs being writable
	var isReadOnly = false;
	var folder = appCtxt.getById(this.folderId);
	var rootId = ZmOrganizer.getSystemId(ZmOrganizer.ID_ROOT);
	while (folder && folder.parent && (folder.parent.id != rootId) && !folder.isReadOnly()) {
		folder = folder.parent;
	}

	if (folder && folder.isReadOnly()) {
		isReadOnly = true;
	}

	return isReadOnly;
};

/**
 * Gets the briefcase folder.
 *
 * @return	{ZmBriefcase}	the folder
 */
ZmBriefcaseBaseItem.prototype.getBriefcaseFolder =
function() {
	if (!this._briefcase) {
		var folder = appCtxt.getById(this.folderId);
		var rootId = ZmOrganizer.getSystemId(ZmOrganizer.ID_ROOT);
		while (folder && folder.parent && (folder.parent.id != rootId)) {
			folder = folder.parent;
		}
		this._briefcase = folder;
	}
	return this._briefcase;
};

/**
 * Checks if this item is shared.
 *
 * @return	{Boolean}	true if this item is shared
 */
ZmBriefcaseBaseItem.prototype.isShared =
function() {
	var briefcase = this.getBriefcaseFolder();
	return briefcase && briefcase.link;
};

/**
 * Creates an item from an attachment.
 *
 * @param	{String}	msgId		the message
 * @param	{String}	partId		the message part
 * @param	{String}	name		the item name
 * @param	{String}	folderId		the folder id
 */
ZmBriefcaseBaseItem.prototype.createFromAttachment =
function(msgId, partId, name, folderId, attribs) {

    attribs = attribs || {};

    var acctId = appCtxt.getActiveAccount().id;

    var json = {
        SaveDocumentRequest: {
            _jsns: "urn:zimbraMail",
			doc: {
                m: {
                    id: msgId,
                    part: partId
                }
            }
        }
    };

    var doc = json.SaveDocumentRequest.doc;
    if (attribs.id && attribs.version) {
        doc.id = attribs.id;
        doc.ver = attribs.version;
    }else{
        doc.l = folderId;
    }
    if(attribs.rename){
        doc.name = attribs.rename;
    }
    var params = {
		jsonObj: json,
		asyncMode: true,
		callback: (new AjxCallback(this, this._handleResponseCreateItem, [folderId, attribs.callback])),
		errorCallback: (new AjxCallback(this, this._handleErrorCreateItem, [attribs.errorCallback]))
	};
    appCtxt.getAppController().sendRequest(params);
};

ZmBriefcaseBaseItem.prototype.restoreVersion =
function(restoreVerion, callback){

    var json = {
		SaveDocumentRequest: {
			_jsns: "urn:zimbraMail",
			doc: {
				id:	this.id,
                ver: this.version,
                doc: {
                    id: this.id,
                    ver: restoreVerion
                }
			}
		}
	};

	var params = {
		jsonObj:		json,
		asyncMode:		true,
		callback:		callback
	};
	return appCtxt.getAppController().sendRequest(params);

};

ZmBriefcaseBaseItem.prototype.deleteVersion =
function(version, callback, batchCmd){

    var json = {
		PurgeRevisionRequest: {
			_jsns: "urn:zimbraMail",
			revision: {
				id:	this.id,
                ver: version,
                includeOlderRevisions: false
			}
		}
	};

    if(batchCmd){
        batchCmd.addRequestParams(json, callback);
    }else{
        var params = {
            jsonObj:		json,
            asyncMode:		true,
            callback:		callback
        };
        return appCtxt.getAppController().sendRequest(params);
    }

};

ZmBriefcaseBaseItem.prototype._handleResponseCreateItem =
function(folderId, callback, response) {
	appCtxt.getAppController().setStatusMsg(ZmMsg.fileCreated);
	appCtxt.getChooseFolderDialog().popdown();
    if(callback)
        callback.run(response);
};

ZmBriefcaseBaseItem.prototype._handleErrorCreateItem =
function(callback, ex) {

    var handled = false;
	if(callback){
        handled = callback.run(ex);
    }
    appCtxt.getAppController().setStatusMsg(ZmMsg.errorCreateFile, ZmStatusView.LEVEL_CRITICAL);
    return handled;
};

ZmBriefcaseBaseItem.prototype.notifyModify =
function(obj, batchMode) {

	var result = ZmItem.prototype.notifyModify.apply(this, arguments);
	if (result) {
		return result;
	}

    var modified = false, doNotify = true, fields=[];
    //Updating modified attributes
    this.set(obj);

    if (doNotify) {
		this._notify(ZmEvent.E_MODIFY, {fields: fields});
	}

};
/**
 * Gets the folder.
 *
 * @return	{ZmFolder}		the folder
 */
ZmBriefcaseBaseItem.prototype.getFolder =
function() {
	return appCtxt.getById(this.folderId);
};

ZmBriefcaseBaseItem.prototype._loadFromDom =
function(node) {

	this.id = node.id;

	if (node.rest)	{ this.restUrl = node.rest; }
	if (node.l)		{ this.folderId = node.l; }
	if (node.name)	{ this.name = node.name; }
	if (node.cr)	{ this.creator = node.cr; }
	if (node.d)		{ this.createDate = new Date(Number(node.d)); }
	if (node.md)	{ //node.md is seconds since epoch
        var mdMilliSecs = Number(node.md)*1000;
        this.modifyDate = new Date(mdMilliSecs);
    }
	if (node.leb)	{ this.modifier = node.leb; }
	if (node.s || node.s == 0) //size can be 0
                    { this.size = Number(node.s); }
	if (node.ver)	{ this.version = Number(node.ver) || 0; }
	if (node.ct)	{ this.contentType = node.ct.split(";")[0]; }
	if (node.tn)	{ this._parseTagNames(node.tn);	}
    this.locked = false;
    if (node.loid)    {
        this.locked = true;
        this.lockId = node.loid;
        this.lockUser = node.loe;
        this.lockTime = new Date(Number(node.lt));
    }

    if (node.desc){  this.notes = AjxStringUtil.htmlEncode(node.desc); }
    this.subject = this.getNotes();

    this._parseFlags(node.f);

};

/**
 * Creates a briefcase item.
 * @class
 * This class represents a briefcase item.
 *
 * @param {int}			id			the unique id
 * @param {ZmList}		list		a list that contains this item
 * @param {Boolean}		noCache		if true, do not cache this item

 * @extends		ZmBriefcaseBaseItem
 *
 * @see		ZmBriefcase
 */
ZmBriefcaseItem = function(id, list, noCache) {

	if (arguments.length == 0) { return; }
	ZmBriefcaseBaseItem.call(this, id, list, noCache, ZmItem.BRIEFCASE_ITEM);
};

ZmBriefcaseItem.prototype = new ZmBriefcaseBaseItem;
ZmBriefcaseItem.prototype.constructor = ZmBriefcaseItem;

/**
 * Returns a string representation of the object.
 *
 * @return		{String}		a string representation of the object
 */
ZmBriefcaseItem.prototype.toString =
function() {
	return "ZmBriefcaseItem";
};

// Static functions
/**
 * Creates a briefcase item from the dom.
 *
 * @param	{Object}	node		the node
 * @param	{Hash}		args		a hash of arguments
 *
 * @return	{ZmBriefcaseItem}	the briefcase item
 */
ZmBriefcaseItem.createFromDom =
function(node, args) {
	var item = new ZmBriefcaseItem(node.id, args.list);
	item._loadFromDom(node);
	return item;
};

ZmBriefcaseItem.getRevision =
function(itemId, version, callback, errorCallback, accountName) {
	var json = {
		ListDocumentRevisionsRequest: {
			_jsns: "urn:zimbraMail",
			doc: {
				id:	itemId,
                ver: version,   //verion=-1 for all versions of count
                count: 50       //parametrize count to allow pagination
			}
		}
	};

	var params = {
		jsonObj:		json,
		asyncMode:		Boolean(callback),
		callback:		callback,
		errorCallback:	errorCallback,
		accountName:	accountName
	};
	return appCtxt.getAppController().sendRequest(params);
};

ZmBriefcaseItem.lock =
function(itemId, callback, errorCallback, accountName) {
	var json = {
		ItemActionRequest: {
			_jsns: "urn:zimbraMail",
			action: {
				id:	itemId instanceof Array ? itemId.join() : itemId,
				op:	"lock"
			}
		}
	};

	var params = {
		jsonObj:		json,
		asyncMode:		Boolean(callback),
		callback:		callback,
		errorCallback:	errorCallback,
		accountName:	accountName
	};
	return appCtxt.getAppController().sendRequest(params);
};

ZmBriefcaseItem.unlock =
function(itemId, callback, errorCallback, accountName) {
	var json = {
		ItemActionRequest: {
			_jsns: "urn:zimbraMail",
			action: {
				id:	itemId instanceof Array ? itemId.join() : itemId,
				op:	"unlock"
			}
		}
	};

	var params = {
		jsonObj:		json,
		asyncMode:		Boolean(callback),
		callback:		callback,
		errorCallback:	errorCallback,
		accountName:	accountName
	};
	return appCtxt.getAppController().sendRequest(params);
};

// Mendoza line

ZmBriefcaseItem.prototype.getRevisions =
function(callback, errorCallback, accountName){
	ZmBriefcaseItem.getRevision(this.id, -1 ,callback, errorCallback, accountName);
};

ZmBriefcaseItem.prototype.lock =
function(callback, errorCallback, accountName){
	ZmBriefcaseItem.lock(this.id, callback, errorCallback, accountName);
};

ZmBriefcaseItem.prototype.unlock =
function(callback, errorCallback, accountName){
	ZmBriefcaseItem.unlock(this.id, callback, errorCallback, accountName);
};

ZmBriefcaseItem.prototype.set =
function(data) {

	this.id = data.id;
	if (data.rest) this.restUrl = data.rest;
	if (data.l) this.folderId = data.l;
	if (data.name) this.name = data.name;
	if (data.cr) this.creator = data.cr;
	if (data.d) this.createDate = new Date(Number(data.d));
	if (data.md)	{ //node.md is seconds since epoch
		var mdMilliSecs = Number(data.md)*1000;
		this.modifyDate = new Date(mdMilliSecs);
	}
	if (data.leb) this.modifier = data.leb;
	if (data.s) this.size = Number(data.s);
	if (data.ver) this.version = Number(data.ver);
	if (data.ct) this.contentType = data.ct.split(";")[0];
    if (data.tn) { this._parseTagNames(data.tn); }
    if (data.loid)    {
        this.locked = true;
        this.lockId = data.loid;
        this.lockUser = data.loe;
        this.lockTime = new Date(Number(data.lt));
    } else if (data.loid===""){
        //loid is not always set in response; set locked to false when value is blank
        this.locked = false;
    }

    if (data.desc)  this.notes = AjxStringUtil.htmlEncode(data.desc);
    this.subject = this.getNotes();
};

ZmBriefcaseItem.prototype.getNotes =
function(){
    return AjxMessageFormat.format(ZmMsg.revisionNotes, [this.version, (this.notes || "")]);
};

/**
 * Gets the normalized item id by splitting it from a/c id if any associated
 *
 * @return	{Int}	normalized item id
 */
ZmBriefcaseItem.prototype.getNormalizedItemId =
function(){
    if(!this.getBriefcaseFolder().isShared()){return this.id;}
    return AjxStringUtil.split(this.id,':')[1];
};

ZmBriefcaseFolderItem = function(folder) {

	ZmBriefcaseItem.call(this, folder.id, null, true);

	this.name = folder.name;
	this.folderId = folder.parent && folder.parent.id;
	this.isFolder = true;
	this.folder = folder;
    this.size = folder.sizeTotal;
    this.creator = folder.getOwner();

	this._data = {};
};

ZmBriefcaseFolderItem.prototype = new ZmBriefcaseItem;
ZmBriefcaseFolderItem.prototype.constructor = ZmBriefcaseFolderItem;

ZmBriefcaseFolderItem.prototype.toString =
function() {
	return "ZmBriefcaseFolderItem";
};

ZmBriefcaseFolderItem.prototype.getData =
function(key) {
	return this._data[key];
};

ZmBriefcaseFolderItem.prototype.setData =
function(key, value) {
  this._data[key] = value;
};

ZmBriefcaseFolderItem.prototype.getIcon =
function(baseIcon, large){
    if(baseIcon)
        return ZmBriefcaseBaseItem.prototype.getIcon.call(this, true);
    else
        return this.folder.getIconWithColor();
};

ZmBriefcaseFolderItem.prototype.getOwner =
function(){
    return this.folder.getOwner();
};

//ZmRevisionItem
ZmRevisionItem = function(id, parentItem){
    if(arguments.length == 0) return;
    this.parent = parentItem;
    this.isRevision = true;
    this.id = id;
    ZmBriefcaseBaseItem.call(this, id, null, false, ZmItem.BRIEFCASE_REVISION_ITEM);
};

ZmRevisionItem.prototype = new ZmBriefcaseBaseItem;
ZmRevisionItem.prototype.constructor = ZmRevisionItem;

ZmRevisionItem.prototype.toString = function() {
	return "ZmRevisionItem";
}
ZmRevisionItem.prototype.set =
function(data){

    //Props
    //this.id =       this.id || data.id;
    this.version =  data.ver;
    if (data.name)  this.name = data.name;
    if (data.l)     this.folderId = data.l;
    if (data.ct)    this.contentType = data.ct.split(";")[0];
    if (data.s)     this.size = Number(data.s);

    //Data
    if (data.cr)    this.creator = data.cr;
    if (data.cd)    this.createDate = new Date(Number(data.cd));
    if (data.leb)   this.modifier = data.leb;
	if (data.md)	{ //node.md is seconds since epoch
		var mdMilliSecs = Number(data.md)*1000;
		this.modifyDate = new Date(mdMilliSecs);
	}
	if (data.desc)  this.notes = AjxStringUtil.htmlEncode(data.desc);

    this.subject = this.getNotes();
	if (data.tn) { this._parseTagNames(data.tn); }

};

ZmRevisionItem.prototype.getNotes =
function(){
    return ((this.notes)?AjxMessageFormat.format(ZmMsg.revisionNotes, [this.version, this.notes]):AjxMessageFormat.format(ZmMsg.revisionWithoutNotes, [this.version]));
};

ZmRevisionItem.prototype.getRestUrl =
function(){
    var restUrl = this.parent.getRestUrl();
    if(this.version){
        restUrl = restUrl + ( restUrl.match(/\?/) ? '&' : '?' ) + "ver="+this.version;
    }
    return restUrl;
};

ZmRevisionItem.prototype.getIcon =
function(){
   return null;
};

/**
 * Rename the item.
 *
 * @param	{String}	newName
 * @param	{AjxCallback}	callback		the callback
 * @param	{AjxCallback}	errorCallback	the callback on error
 * @return	{Object}		the result of the move
 */
ZmRevisionItem.prototype.rename =
function(newName, callback, errorCallback) {
	return ZmItem.rename(this.parent.id, newName, callback, errorCallback);
};


text:
#ifndef WLF_CHANNELS_H
#define WLF_CHANNELS_H

#include <freerdp/freerdp.h>
#include <freerdp/client/channels.h>
#include <freerdp/client/rdpei.h>
#include <freerdp/client/tsmf.h>
#include <freerdp/client/rail.h>
#include <freerdp/client/cliprdr.h>
#include <freerdp/client/rdpgfx.h>
#include <freerdp/client/encomsp.h>

int wlf_on_channel_connected(freerdp* instance, const char* name,
                             void* pInterface);
int wlf_on_channel_disconnected(freerdp* instance, const char* name,
                                void* pInterface);

void wlf_OnChannelConnectedEventHandler(rdpContext* context,
                                        ChannelConnectedEventArgs* e);
void wlf_OnChannelDisconnectedEventHandler(rdpContext* context,
        ChannelDisconnectedEventArgs* e);

#endif


text:
@implementation NSDictionary (Log)
- (NSString *)descriptionWithLocale:(id)locale
{
    NSMutableString *string = [NSMutableString string];

    // 开头有个{
    [string appendString:@"{\n"];

    // 遍历所有的键值对
    [self enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
        [string appendFormat:@"\t%@", key];
        [string appendString:@" : "];
        [string appendFormat:@"%@,\n", obj];
    }];

    // 结尾有个}
    [string appendString:@"}"];

    // 查找最后一个逗号
    NSRange range = [string rangeOfString:@"," options:NSBackwardsSearch];
    if (range.location != NSNotFound)
    [string deleteCharactersInRange:range];

    return string;
}
@end

@implementation NSArray (Log)

- (NSString *)descriptionWithLocale:(id)locale
{
    NSMutableString *string = [NSMutableString string];

    // 开头有个[
    [string appendString:@"[\n"];

    // 遍历所有的元素
    [self enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
        [string appendFormat:@"\t%@,\n", obj];
    }];

    // 结尾有个]
    [string appendString:@"]"];

    // 查找最后一个逗号
    NSRange range = [string rangeOfString:@"," options:NSBackwardsSearch];
    if (range.location != NSNotFound)
    [string deleteCharactersInRange:range];

    return string;
}

@end


text:
import os
import struct

from datetime import date, datetime, time, timedelta
from decimal import Decimal
from parquet.ttypes import ColumnIndex, FileMetaData, OffsetIndex, PageHeader, Type
from subprocess import check_call
from thrift.protocol import TCompactProtocol
from thrift.transport import TTransport

PARQUET_VERSION_NUMBER = 'PAR1'

def create_protocol(serialized_object_buffer):
  """Creates a thrift protocol object from a memory buffer. The buffer should
  contain a serialized thrift object.
  """
  transport = TTransport.TMemoryBuffer(serialized_object_buffer)
  return TCompactProtocol.TCompactProtocol(transport)

def julian_day_to_date(julian_day):
  """Converts a julian day number into a Gregorian date. The reference date is picked
  arbitrarily and can be validated with an online converter like
  http://aa.usno.navy.mil/jdconverter?ID=AA&jd=2457755
  """
  return date(2017, 01, 01) + timedelta(julian_day - 2457755)

def nanos_to_time(nanos):
  """Converts nanoseconds to time of day."""
  micros = nanos // 1000  # integer division
  seconds, micros = divmod(micros, 10**6)
  minutes, seconds = divmod(seconds, 60)
  hours, minutes = divmod(minutes, 60)
  return time(hours, minutes, seconds, micros)

def parse_boolean(s):
  """Parses a single boolean value from a single byte"""
  return struct.unpack('<?', s)[0]

def parse_int32(s):
  """Reinterprets the string 's' as a signed 4-byte integer."""
  return struct.unpack('<i', s)[0]

def parse_int64(s):
  """Reinterprets the string 's' as a signed 8-byte integer."""
  return struct.unpack('<q', s)[0]

def parse_float(s):
  """Reinterprets the string 's' as an IEEE single precision float."""
  return struct.unpack('<f', s)[0]

def parse_double(s):
  """Reinterprets the string 's' as an IEEE double precision float."""
  return struct.unpack('<d', s)[0]

def decode_timestamp(s):
  """Reinterprets the string 's' as a 12-byte timestamp as written by Impala and decode it
  into a datetime object.
  """
  # Impala writes timestamps as 12-byte values. The first 8 byte store a
  # boost::posix_time::time_duration, which is the time within the current day in
  # nanoseconds stored as int64. The last 4 bytes store a boost::gregorian::date,
  # which is the Julian date, stored as utin32.
  day_nanos, julian_day = struct.unpack('<qI', s)
  return datetime.combine(julian_day_to_date(julian_day), nanos_to_time(day_nanos))

def decode_decimal(schema, value):
  """Decodes 'value' into a decimal by interpreting its contents according to 'schema'."""
  assert len(value) > 0
  assert schema.type_length == len(value)
  assert schema.type == Type.FIXED_LEN_BYTE_ARRAY

  numeric = Decimal(reduce(lambda x, y: x * 256 + y, map(ord, value)))

  # Compute two's complement for negative values.
  if (ord(value[0]) > 127):
    bit_width = 8 * len(value)
    numeric = numeric - (2 ** bit_width)

  return numeric / 10 ** schema.scale

def decode_stats_value(schema, value):
  """Decodes 'value' according to 'schema. It expects 'value' to be plain encoded. For
  BOOLEAN values, only the least significant bit is parsed and returned. Binary arrays are
  expected to be stored as such, without a preceding length.
  """
  column_type = schema.type
  if column_type == Type.BOOLEAN:
    return parse_boolean(value)
  elif column_type == Type.INT32:
    return parse_int32(value)
  elif column_type == Type.INT64:
    return parse_int64(value)
  elif column_type == Type.INT96:
    # Impala uses INT96 to store timestamps
    return decode_timestamp(value)
  elif column_type == Type.FLOAT:
    return parse_float(value)
  elif column_type == Type.DOUBLE:
    return parse_double(value)
  elif column_type == Type.BYTE_ARRAY:
    # In parquet::Statistics, strings are stored as is.
    return value
  elif column_type == Type.FIXED_LEN_BYTE_ARRAY:
    return decode_decimal(schema, value)
  assert False
  return None

def read_serialized_object(thrift_class, file, file_pos, length):
  """Reads an instance of class 'thrift_class' from an already opened file at the
  given position.
  """
  file.seek(file_pos)
  serialized_thrift_object = file.read(length)
  protocol = create_protocol(serialized_thrift_object)
  thrift_object = thrift_class()
  thrift_object.read(protocol)
  return thrift_object

def get_parquet_metadata(filename):
  """Returns a FileMetaData as defined in parquet.thrift. 'filename' must be a local
  file path.
  """
  file_size = os.path.getsize(filename)
  with open(filename) as f:
    # Check file starts and ends with magic bytes
    start_magic = f.read(len(PARQUET_VERSION_NUMBER))
    assert start_magic == PARQUET_VERSION_NUMBER

    f.seek(file_size - len(PARQUET_VERSION_NUMBER))
    end_magic = f.read(len(PARQUET_VERSION_NUMBER))
    assert end_magic == PARQUET_VERSION_NUMBER

    # Read metadata length
    f.seek(file_size - len(PARQUET_VERSION_NUMBER) - 4)
    metadata_len = parse_int32(f.read(4))

    # Calculate metadata position in file
    metadata_pos = file_size - len(PARQUET_VERSION_NUMBER) - 4 - metadata_len

    # Return deserialized FileMetaData object
    return read_serialized_object(FileMetaData, f, metadata_pos, metadata_len)

def get_parquet_metadata_from_hdfs_folder(hdfs_path, tmp_dir):
  """Returns a list with the FileMetaData of every file in 'hdfs_path' and its
  subdirectories. The hdfs folder is copied into 'tmp_dir' before processing.
  """
  check_call(['hdfs', 'dfs', '-get', hdfs_path, tmp_dir])
  result = []
  for root, subdirs, files in os.walk(tmp_dir):
    for f in files:
      if not f.endswith('parq'):
        continue
      parquet_file = os.path.join(root, str(f))
      file_meta_data = get_parquet_metadata(parquet_file)
      result.append(file_meta_data)
  return result