public SkillInfoTableRecord(DataRecord dataRecord)
        {
            ValueStr = dataRecord;
            Id = ValueStr[0];

            Step = new List<SkillStepTableRecord>();
        }

 public void public_constructor_assigns_given_header_record()
 {
     var header = new HeaderRecord();
     var data = new DataRecord(header);
     Assert.NotNull(data.HeaderRecord);
     Assert.Same(header, data.HeaderRecord);
 }

        public void parser_complies_with_rule_RL()
        {
            var csv = "Kent,25,M,{0}Belinda,26,F{0}Tempany,0,F,{1}";
            string[] lineBreaks = { "\r\n", "\r", "\n" };
            string[] eofMarkers = { "\r\n", "\r", "\n", string.Empty };

            foreach (var lineBreak in lineBreaks)
            {
                foreach (var eofMarker in eofMarkers)
                {
                    var parser = this.CreateParserFromString(string.Format(csv, lineBreak, eofMarker));
                    var records = new DataRecord[3];

                    Assert.Equal(3, parser.ParseRecords(null, records, 0, records.Length));

                    Assert.Equal("Kent", records[0][0]);
                    Assert.Equal("25", records[0][1]);
                    Assert.Equal("M", records[0][2]);
                    Assert.Equal("", records[0][3]);

                    Assert.Equal("Belinda", records[1][0]);
                    Assert.Equal("26", records[1][1]);
                    Assert.Equal("F", records[1][2]);

                    Assert.Equal("Tempany", records[2][0]);
                    Assert.Equal("0", records[2][1]);
                    Assert.Equal("F", records[2][2]);
                    Assert.Equal("", records[2][3]);

                    Assert.False(parser.HasMoreRecords);
                }
            }
        }

        public void indexer_get_returns_corresponding_value_for_column()
        {
            var data = new DataRecord(new HeaderRecord(new string[] { "Name", "Age", "Gender" }), new string[] { "Kent", "25", "M" });

            Assert.Equal("Kent", data["Name"]);
            Assert.Equal("25", data["Age"]);
            Assert.Equal("M", data["Gender"]);
        }

        public void TestSimpleConverterForNull()
        {
            var record = new DataRecord(new Tuple<string, object>("Id", null));
            _mapper.Column(model => model.Id, "Id", ctx => int.Parse(ctx.ColumnValue.As<string>() ?? "0"));

            var user = new TestUser();
            _mapper.Map(user, record);
            Assert.Equal(0, user.Id);
        }

        public void TestSimpleConverterForIntToString()
        {
            var record = new DataRecord(new Tuple<string, object>("Name", 42));
            _mapper.Column(model => model.Name, "Name", ctx => ctx.ColumnValue.As<string>());

            var user = new TestUser();
            _mapper.Map(user, record);
            Assert.Equal("42", user.Name);
        }

        protected virtual void OnRaiseDataEvent(DataRecord.DataEvent e)
        {
            EventHandler<DataRecord.DataEvent> handler = RaiseDataEvent;

            if (handler != null)
            {
            handler(this, e);
            }
        }

        public void indexer_get_throws_if_column_not_found()
        {
            var data = new DataRecord(new HeaderRecord(new string[] { "Name", "Age", "Gender" }), new string[] { "Kent", "25", "M" });
            string s;

            Assert.Throws<ArgumentException>(() => s = data["foo"]);
            Assert.Throws<ArgumentException>(() => s = data["name"]);
            var ex = Assert.Throws<ArgumentException>(() => s = data["GENDER"]);
            Assert.Equal("No column named 'GENDER' was found in the header record.", ex.Message);
        }

 public VehicleAdditionalDetails BuildFromCSV(DataRecord data)
 {
     Manufacturer = data["MANUFACTURER"];
     Model = data["MODEL"];
     RegistrationYearAndLetter = data["REGYEAR"];
     NumberOfDoors = data["NOOFDOORS"];
     Transmission = data["TRANSMISSION"];
     VehicleDescription = data["VEHICLEDESCRIPTION"];
     return new VehicleAdditionalDetails(Manufacturer, Model, RegistrationYearAndLetter, NumberOfDoors, Transmission, VehicleDescription);
 }

        public void TestPrimaryKey()
        {
            _mapper.PrimaryKey(model => model.Id, "Id");
            Assert.Equal("Id", _mapper.PrimaryKeys.First());
            Assert.Equal("Id", _mapper.GetColumnName("Id"));

            var record = new DataRecord();
            record.Fields.Add(new Tuple<string, object>("Id", 10));
            var user = new TestUser();
            _mapper.Map(user, record);
            Assert.Equal(10, user.Id);
        }

        protected override void sendRecord(DataRecord.DataRecord dr)
        {
            System.Console.WriteLine("Sending.");
              if (serv == null) throw new System.ArgumentNullException("TCPServer", "Client requires a reference to a TCP server.");

              //System.Console.WriteLine("Sending data to {0}.", client);
              try {
            serv.SendToClient(dr.getRecordAsJson(), client);
              } catch (Exception ex) {
            System.Console.WriteLine("Could not send data to {0}.", client);
              }
        }

 /// Process the DataRecord. This is done asynchronously.
 public void process(ref DataRecord.DataRecord incoming)
 {
     bool runme = true;
       try{
     foreach (string field in requiredDataFields){
       if (!incoming.updated_fields.Contains(field))
       runme = false;
     }
     if (runme) this.run(incoming);
     this.run(incoming);
       } catch (Exception ex){ throw ex;}
       incoming.addData(data);
 }

        protected override void run(DataRecord.DataRecord incoming)
        {
            // Sometimes the data trasmission is poor.
              Types.Skeleton skel = incoming.getData("Skeleton");
              if (skel._empty) return;

              // Must add the avatar's skeleton before the player's.
              mov.addAvatar(skel);
              mov.addPlayer(skel);

              // Calculate the total angular displacement.
              mov.run();
              data["ExerciseAdherence"] = mov.getFlail();
        }

        public void parser_complies_with_2_4()
        {
            var csv = $"aaa,bbb,ccc";
            var parser = this.CreateParserFromString(csv);
            var records = new DataRecord[1];

            Assert.Equal(1, parser.ParseRecords(null, records, 0, records.Length));

            Assert.Equal("aaa", records[0][0]);
            Assert.Equal("bbb", records[0][1]);
            Assert.Equal("ccc", records[0][2]);

            Assert.False(parser.HasMoreRecords);
        }

        public void issue3_repro()
        {
            var csv = @"Col1,Col2,Col3
val1,val2,val3
val1,val2,";

            using (var reader = CsvReader.FromCsvString(csv))
            {
                reader.ReadHeaderRecord();
                var buffer = new DataRecord[100];
                var read = reader.ReadDataRecords(buffer, 0, buffer.Length);

                Assert.Equal(2, read);
            }
        }

        public async Task issue3_repro_async()
        {
            var csv = @"Col1,Col2,Col3
val1,val2,val3
val1,val2,";

            using (var reader = CsvReader.FromCsvString(csv))
            {
                await reader.ReadHeaderRecordAsync();
                var buffer = new DataRecord[100];
                var read = await reader.ReadDataRecordsAsync(buffer, 0, buffer.Length);

                Assert.Equal(2, read);
            }
        }

        /// <summary>
        /// Copies all remaining records in <paramref name="this"/> to <paramref name="destination"/>.
        /// </summary>
        /// <param name="this">
        /// The data source.
        /// </param>
        /// <param name="destination">
        /// The data destination.
        /// </param>
        /// <returns>
        /// The number of records written to <paramref name="destination"/>.
        /// </returns>
        public static int CopyTo(this CsvReader @this, CsvWriter destination)
        {
            @this.AssertNotNull("@this");
            destination.AssertNotNull("destination");

            var num = 0;
            var buffer = new DataRecord[16];
            var read = 0;

            while ((read = @this.ReadDataRecords(buffer, 0, buffer.Length)) != 0)
            {
                destination.WriteRecords(buffer, 0, read);
                num += read;
            }

            return num;
        }

        public void trailing_whitespace_is_retained_when_preserve_trailing_whitespace_is_true()
        {
            var csv = @"value1 ,value2  	,value3   	     		 
value4,value5   ,value6	";
            var parser = this.CreateParserFromString(csv);
            parser.PreserveTrailingWhiteSpace = true;
            var records = new DataRecord[2];

            Assert.Equal(2, parser.ParseRecords(null, records, 0, records.Length));

            Assert.Equal("value1 ", records[0][0]);
            Assert.Equal("value2  	", records[0][1]);
            Assert.Equal("value3   	     		 ", records[0][2]);
            Assert.Equal("value4", records[1][0]);
            Assert.Equal("value5   ", records[1][1]);
            Assert.Equal("value6	", records[1][2]);
        }

        public void data_record_creation()
        {
            var repeatCount = 1000000;
            var creationCount = 0L;

            for (var i = 0; i < repeatCount; ++i)
            {
                var dataRecord = new DataRecord();

                // ensure optimization doesn't remove the object creation
                creationCount += dataRecord.Count;

                ++creationCount;
            }

            Assert.Equal(repeatCount, creationCount);
        }

        public void leading_whitespace_is_discarded_when_preserve_leading_whitespace_is_false()
        {
            var csv = @" value1,  	value2,   	     		 value3
value4,   value5,	value6";
            var parser = this.CreateParserFromString(csv);
            parser.PreserveLeadingWhiteSpace = false;
            var records = new DataRecord[2];

            Assert.Equal(2, parser.ParseRecords(null, records, 0, records.Length));

            Assert.Equal("value1", records[0][0]);
            Assert.Equal("value2", records[0][1]);
            Assert.Equal("value3", records[0][2]);
            Assert.Equal("value4", records[1][0]);
            Assert.Equal("value5", records[1][1]);
            Assert.Equal("value6", records[1][2]);
        }