diff --git a/main/SS/UserModel/Chart.cs b/main/SS/UserModel/Chart.cs
index 846cce728..a6abac2bd 100644
--- a/main/SS/UserModel/Chart.cs
+++ b/main/SS/UserModel/Chart.cs
@@ -14,12 +14,12 @@ public interface IChart : ManuallyPositionable
         /**
          * @return an appropriate ChartDataFactory implementation
          */
-        IChartDataFactory GetChartDataFactory();
+        IChartDataFactory ChartDataFactory { get; }
 
         /**
          * @return an appropriate ChartAxisFactory implementation
          */
-        IChartAxisFactory GetChartAxisFactory();
+        IChartAxisFactory ChartAxisFactory { get; }
 
         /**
          * @return chart legend instance
diff --git a/main/SS/UserModel/Charts/ChartAxis.cs b/main/SS/UserModel/Charts/ChartAxis.cs
index c969cd918..0a7350d83 100644
--- a/main/SS/UserModel/Charts/ChartAxis.cs
+++ b/main/SS/UserModel/Charts/ChartAxis.cs
@@ -30,99 +30,82 @@ public interface IChartAxis
         /**
          * @return axis id
          */
-        long GetId();
+        long Id { get; }
 
         /**
-         * @return axis position
+         * get or set axis position
          */
-        AxisPosition GetPosition();
+        AxisPosition Position { get; set; }
 
         /**
-         * @param position new axis position
+         * get or set axis number format
          */
-        void SetPosition(AxisPosition position);
-
-        /**
-         * @return axis number format
-         */
-        String GetNumberFormat();
-
-        /**
-         * @param format axis number format
-         */
-        void SetNumberFormat(String format);
+        String NumberFormat { get; set; }
 
         /**
          * @return true if log base is defined, false otherwise
          */
-        bool IsSetLogBase();
+        bool IsSetLogBase { get; }
 
         /**
          * @param logBase a number between 2 and 1000 (inclusive)
-         * @throws ArgumentException if log base not within allowed range
-         */
-        void SetLogBase(double logBase);
-
-        /**
          * @return axis log base or 0.0 if not Set
+         * @throws ArgumentException if log base not within allowed range
          */
-        double GetLogBase();
+        double LogBase { get; set; }
 
         /**
          * @return true if minimum value is defined, false otherwise
          */
-        bool IsSetMinimum();
+        bool IsSetMinimum { get; }
 
         /**
-         * @return axis minimum or 0.0 if not Set
+         * get or set axis minimum 
+         * 0.0 if not Set
          */
-        double GetMinimum();
-
-        /**
-         * @param min axis minimum
-         */
-        void SetMinimum(double min);
+        double Minimum { get; set; }
 
         /**
          * @return true if maximum value is defined, false otherwise
          */
-        bool IsSetMaximum();
+        bool IsSetMaximum { get; }
 
         /**
-         * @return axis maximum or 0.0 if not Set
+         * get or set axis maximum 
+         * 0.0 if not Set
          */
-        double GetMaximum();
+        double Maximum { get; set; }
 
         /**
-         * @param max axis maximum
+         * get or set axis orientation
          */
-        void SetMaximum(double max);
+        AxisOrientation Orientation { get; set; }
 
         /**
-         * @return axis orientation
+         * get or set axis cross type
          */
-        AxisOrientation GetOrientation();
+        AxisCrosses Crosses { get; set; }
 
         /**
-         * @param orientation axis orientation
+         * Declare this axis cross another axis.
+         * @param axis that this axis should cross
          */
-        void SetOrientation(AxisOrientation orientation);
+        void CrossAxis(IChartAxis axis);
 
         /**
-         * @param crosses axis cross type
+         * @return visibility of the axis.
          */
-        void SetCrosses(AxisCrosses crosses);
+        bool IsVisible { get; set; }
 
         /**
-         * @return axis cross type
+         * @return major tick mark.
          */
-        AxisCrosses GetCrosses();
+        AxisTickMark MajorTickMark { get; set; }
 
         /**
-         * Declare this axis cross another axis.
-         * @param axis that this axis should cross
+         * @return minor tick mark.
          */
-        void CrossAxis(IChartAxis axis);
+        AxisTickMark MinorTickMark { get; set; }
     }
 
 
diff --git a/ooxml/OpenXmlFormats/Drawing/Chart/Chart.cs b/ooxml/OpenXmlFormats/Drawing/Chart/Chart.cs
index d00cdd266..cecf2bb60 100644
--- a/ooxml/OpenXmlFormats/Drawing/Chart/Chart.cs
+++ b/ooxml/OpenXmlFormats/Drawing/Chart/Chart.cs
@@ -6126,6 +6126,24 @@ public List<CT_Extension> extLst
                 this.extLstField = value;
             }
         }
+
+        public CT_Boolean AddNewDelete()
+        {
+            this.deleteField = new CT_Boolean();
+            return this.deleteField;
+        }
+
+        public CT_TickMark AddNewMajorTickMark()
+        {
+            this.majorTickMarkField = new CT_TickMark();
+            return this.majorTickMarkField;
+        }
+
+        public CT_TickMark AddNewMinorTickMark()
+        {
+            this.minorTickMarkField = new CT_TickMark();
+            return this.minorTickMarkField;
+        }
     }
 
 
diff --git a/ooxml/XSSF/UserModel/Charts/XSSFCategoryAxis.cs b/ooxml/XSSF/UserModel/Charts/XSSFCategoryAxis.cs
index 294cc0d87..d2a2bbbb9 100644
--- a/ooxml/XSSF/UserModel/Charts/XSSFCategoryAxis.cs
+++ b/ooxml/XSSF/UserModel/Charts/XSSFCategoryAxis.cs
@@ -26,9 +26,12 @@ public XSSFCategoryAxis(XSSFChart chart, CT_CatAx ctCatAx)
             this.ctCatAx = ctCatAx;
         }
 
-        public override long GetId()
+        public override long Id
         {
-            return ctCatAx.axId.val;
+            get
+            {
+                return ctCatAx.axId.val;
+            }
         }
 
         protected override CT_AxPos GetCTAxPos()
@@ -72,7 +75,7 @@ protected override CT_TickMark GetMinorCTTickMark()
 
         public override void CrossAxis(IChartAxis axis)
         {
-            ctCatAx.crossAx.val = (uint)axis.GetId();
+            ctCatAx.crossAx.val = (uint)axis.Id;
         }
 
         private void createAxis(long id, AxisPosition pos)
@@ -89,12 +92,12 @@ private void createAxis(long id, AxisPosition pos)
             ctCatAx.AddNewMinorTickMark();
 
             
-            this.SetPosition(pos);
-            this.SetOrientation(AxisOrientation.MinToMax);
-            this.SetCrosses(AxisCrosses.AutoZero);
+            this.Position=(pos);
+            this.Orientation=(AxisOrientation.MinToMax);
+            this.Crosses=(AxisCrosses.AutoZero);
             this.IsVisible = true;
-            this.SetMajorTickMark(AxisTickMark.Cross);
-            this.SetMinorTickMark(AxisTickMark.None);
+            this.MajorTickMark=(AxisTickMark.Cross);
+            this.MinorTickMark=(AxisTickMark.None);
         }
     }
 }
diff --git a/ooxml/XSSF/UserModel/Charts/XSSFChartAxis.cs b/ooxml/XSSF/UserModel/Charts/XSSFChartAxis.cs
index 5c8d46cd5..4c4c20cc1 100644
--- a/ooxml/XSSF/UserModel/Charts/XSSFChartAxis.cs
+++ b/ooxml/XSSF/UserModel/Charts/XSSFChartAxis.cs
@@ -38,152 +38,210 @@ protected XSSFChartAxis(XSSFChart chart)
         {
             this.chart = chart;
         }
-        public abstract long GetId();
+        public abstract long Id { get;}
         public abstract void CrossAxis(IChartAxis axis);
 
-        public AxisPosition GetPosition()
+        public AxisPosition Position
         {
-            return toAxisPosition(GetCTAxPos());
+            get
+            {
+                return toAxisPosition(GetCTAxPos());
+            }
+            set
+            {
+                GetCTAxPos().val = fromAxisPosition(value);
+            }
         }
 
-        public void SetPosition(AxisPosition position)
+        public String NumberFormat
         {
-            GetCTAxPos().val = fromAxisPosition(position);
+            get
+            {
+                return GetCTNumFmt().formatCode;
+            }
+            set
+            {
+                GetCTNumFmt().formatCode = value;
+                GetCTNumFmt().sourceLinked = true;
+            }
         }
 
-        public void SetNumberFormat(String format)
+        public bool IsSetLogBase
         {
-            GetCTNumFmt().formatCode=format;
-            GetCTNumFmt().sourceLinked = true;
+            get
+            {
+                return GetCTScaling().IsSetLogBase();
+            }
         }
 
-        public String GetNumberFormat()
+        public double LogBase
         {
-            return GetCTNumFmt().formatCode;
+            get
+            {
+                CT_LogBase logBase = GetCTScaling().logBase;
+                if (logBase != null)
+                {
+                    return logBase.val;
+                }
+                return 0.0;
+            }
+            set
+            {
+                if (value < Min_LOG_BASE ||
+                Max_LOG_BASE < value)
+                {
+                    throw new ArgumentException("Axis log base must be between 2 and 1000 (inclusive), got: " + value);
+                }
+                CT_Scaling scaling = GetCTScaling();
+                if (scaling.IsSetLogBase())
+                {
+                    scaling.logBase.val = value;
+                }
+                else
+                {
+                    scaling.AddNewLogBase().val = (value);
+                }
+            }
         }
 
-        public bool IsSetLogBase()
+        public bool IsSetMinimum
         {
-            return GetCTScaling().IsSetLogBase();
+            get
+            {
+                return GetCTScaling().IsSetMin();
+            }
         }
 
-        public void SetLogBase(double logBase)
+        public double Minimum
         {
-            if (logBase < Min_LOG_BASE ||
-                Max_LOG_BASE < logBase)
-            {
-                throw new ArgumentException("Axis log base must be between 2 and 1000 (inclusive), got: " + logBase);
-            }
-            CT_Scaling scaling = GetCTScaling();
-            if (scaling.IsSetLogBase())
+            get
             {
-                scaling.logBase.val = logBase;
+                CT_Scaling scaling = GetCTScaling();
+                if (scaling.IsSetMin())
+                {
+                    return scaling.min.val;
+                }
+                else
+                {
+                    return 0.0;
+                }
             }
-            else
+            set
             {
-                scaling.AddNewLogBase().val = (logBase);
+                CT_Scaling scaling = GetCTScaling();
+                if (scaling.IsSetMin())
+                {
+                    scaling.min.val = value;
+                }
+                else
+                {
+                    scaling.AddNewMin().val = value;
+                }
             }
         }
 
-        public double GetLogBase()
+        public bool IsSetMaximum
         {
-            CT_LogBase logBase = GetCTScaling().logBase;
-            if (logBase != null)
+            get
             {
-                return logBase.val;
+                return GetCTScaling().IsSetMax();
             }
-            return 0.0;
-        }
-
-        public bool IsSetMinimum()
-        {
-            return GetCTScaling().IsSetMin();
         }
 
-        public void SetMinimum(double min)
+        public double Maximum
         {
-            CT_Scaling scaling = GetCTScaling();
-            if (scaling.IsSetMin())
+            get
             {
-                scaling.min.val = min;
+                CT_Scaling scaling = GetCTScaling();
+                if (scaling.IsSetMax())
+                {
+                    return scaling.max.val;
+                }
+                else
+                {
+                    return 0.0;
+                }
             }
-            else
+            set
             {
-                scaling.AddNewMin().val = min;
+                CT_Scaling scaling = GetCTScaling();
+                if (scaling.IsSetMax())
+                {
+                    scaling.max.val = value;
+                }
+                else
+                {
+                    scaling.AddNewMax().val = value;
+                }
             }
         }
 
-        public double GetMinimum()
+        public AxisOrientation Orientation
         {
-            CT_Scaling scaling = GetCTScaling();
-            if (scaling.IsSetMin())
+            get
             {
-                return scaling.min.val;
+                return toAxisOrientation(GetCTScaling().orientation);
             }
-            else
+            set
             {
-                return 0.0;
+                CT_Scaling scaling = GetCTScaling();
+                ST_Orientation stOrientation = fromAxisOrientation(value);
+                if (scaling.IsSetOrientation())
+                {
+                    scaling.orientation.val = stOrientation;
+                }
+                else
+                {
+                    GetCTScaling().AddNewOrientation().val = stOrientation;
+                }
             }
         }
 
-        public bool IsSetMaximum()
+        public AxisCrosses Crosses
         {
-            return GetCTScaling().IsSetMax();
-        }
-
-        public void SetMaximum(double max)
-        {
-            CT_Scaling scaling = GetCTScaling();
-            if (scaling.IsSetMax())
+            get
             {
-                scaling.max.val=max;
+                return toAxisCrosses(GetCTCrosses());
             }
-            else
+            set
             {
-                scaling.AddNewMax().val = max;
+                GetCTCrosses().val = fromAxisCrosses(value);
             }
         }
-
-        public double GetMaximum()
+        public bool IsVisible
         {
-            CT_Scaling scaling = GetCTScaling();
-            if (scaling.IsSetMax())
+            get
             {
-                return scaling.max.val;
+                return GetDelete().val == 1;
             }
-            else
+            set
             {
-                return 0.0;
+                GetDelete().val = value ? 1 : 0;
             }
         }
 
-        public AxisOrientation GetOrientation()
+        public AxisTickMark MajorTickMark
         {
-            return toAxisOrientation(GetCTScaling().orientation);
-        }
-
-        public void SetOrientation(AxisOrientation orientation)
-        {
-            CT_Scaling scaling = GetCTScaling();
-            ST_Orientation stOrientation = fromAxisOrientation(orientation);
-            if (scaling.IsSetOrientation())
+            get
             {
-                scaling.orientation.val = stOrientation;
+                return toAxisTickMark(GetMajorCTTickMark());
             }
-            else
+            set
             {
-                GetCTScaling().AddNewOrientation().val= stOrientation;
+                GetMajorCTTickMark().val = fromAxisTickMark(value);
             }
         }
 
-        public AxisCrosses GetCrosses()
-        {
-            return toAxisCrosses(GetCTCrosses());
-        }
-
-        public void SetCrosses(AxisCrosses crosses)
+        public AxisTickMark MinorTickMark
         {
-            GetCTCrosses().val = fromAxisCrosses(crosses);
+            get
+            {
+                return toAxisTickMark(GetMinorCTTickMark());
+            }
+            set
+            {
+                GetMinorCTTickMark().val = fromAxisTickMark(value);
+            }
         }
 
         protected abstract CT_AxPos GetCTAxPos();
@@ -288,37 +346,6 @@ private static AxisTickMark toAxisTickMark(CT_TickMark ctTickMark)
                 default: return AxisTickMark.Cross;
             }
         }
-        public bool IsVisible
-        {
-            get
-            {
-                return GetDelete().val==1;
-            }
-            set 
-            {
-                GetDelete().val = value?1:0;
-            }
-        }
-
-        public AxisTickMark GetMajorTickMark()
-        {
-            return toAxisTickMark(GetMajorCTTickMark());
-        }
-
-        public void SetMajorTickMark(AxisTickMark tickMark)
-        {
-            GetMajorCTTickMark().val = fromAxisTickMark(tickMark);
-        }
-
-        public AxisTickMark GetMinorTickMark()
-        {
-            return toAxisTickMark(GetMinorCTTickMark());
-        }
-
-        public void SetMinorTickMark(AxisTickMark tickMark)
-        {
-            GetMinorCTTickMark().val =fromAxisTickMark(tickMark);
-        }
     }
 
 }
\ No newline at end of file
diff --git a/ooxml/XSSF/UserModel/Charts/XSSFLineChartData.cs b/ooxml/XSSF/UserModel/Charts/XSSFLineChartData.cs
index 8c35859ac..09a56fafd 100644
--- a/ooxml/XSSF/UserModel/Charts/XSSFLineChartData.cs
+++ b/ooxml/XSSF/UserModel/Charts/XSSFLineChartData.cs
@@ -99,7 +99,7 @@ public void FillChart(SS.UserModel.IChart chart, params IChartAxis[] axis)
 
             foreach (IChartAxis ax in axis)
             {
-                lineChart.AddNewAxId().val = (uint)ax.GetId();
+                lineChart.AddNewAxId().val = (uint)ax.Id;
             }
         }
     }
diff --git a/ooxml/XSSF/UserModel/Charts/XSSFScatterChartData.cs b/ooxml/XSSF/UserModel/Charts/XSSFScatterChartData.cs
index 2e4881aa1..ff373bdce 100644
--- a/ooxml/XSSF/UserModel/Charts/XSSFScatterChartData.cs
+++ b/ooxml/XSSF/UserModel/Charts/XSSFScatterChartData.cs
@@ -146,7 +146,7 @@ public void FillChart(IChart chart, IChartAxis[] axis)
 
             foreach (IChartAxis ax in axis)
             {
-                scatterChart.AddNewAxId().val = (uint)ax.GetId();
+                scatterChart.AddNewAxId().val = (uint)ax.Id;
             }
         }
 
diff --git a/ooxml/XSSF/UserModel/Charts/XSSFValueAxis.cs b/ooxml/XSSF/UserModel/Charts/XSSFValueAxis.cs
index f17edcbba..178a281fe 100644
--- a/ooxml/XSSF/UserModel/Charts/XSSFValueAxis.cs
+++ b/ooxml/XSSF/UserModel/Charts/XSSFValueAxis.cs
@@ -45,9 +45,12 @@ public XSSFValueAxis(XSSFChart chart, CT_ValAx ctValAx)
             this.ctValAx = ctValAx;
         }
 
-        public override long GetId()
+        public override long Id
         {
-            return ctValAx.axId.val;
+            get
+            {
+                return ctValAx.axId.val;
+            }
         }
 
         public void SetCrossBetween(AxisCrossBetween crossBetween)
@@ -101,7 +104,7 @@ protected override CT_Crosses GetCTCrosses()
 
         public override void CrossAxis(IChartAxis axis)
         {
-            ctValAx.crossAx.val= (uint)axis.GetId();
+            ctValAx.crossAx.val= (uint)axis.Id;
         }
 
         private void CreateAxis(long id, AxisPosition pos)
@@ -114,11 +117,17 @@ private void CreateAxis(long id, AxisPosition pos)
             ctValAx.AddNewCrosses();
             ctValAx.AddNewCrossAx();
             ctValAx.AddNewTickLblPos().val = ST_TickLblPos.nextTo;
+            ctValAx.AddNewDelete();
+            ctValAx.AddNewMajorTickMark();
+            ctValAx.AddNewMinorTickMark();
 
-            SetPosition(pos);
-            SetOrientation(AxisOrientation.MinToMax);
+            Position=(pos);
+            Orientation=(AxisOrientation.MinToMax);
             SetCrossBetween(AxisCrossBetween.MidpointCategory);
-            SetCrosses(AxisCrosses.AutoZero);
+            Crosses=(AxisCrosses.AutoZero);
+            IsVisible=(true);
+            MajorTickMark = (AxisTickMark.Cross);
+            MinorTickMark=(AxisTickMark.None);
         }
 
         private static ST_CrossBetween fromCrossBetween(AxisCrossBetween crossBetween)
diff --git a/ooxml/XSSF/UserModel/XSSFChart.cs b/ooxml/XSSF/UserModel/XSSFChart.cs
index 8dba4943c..8093e1890 100644
--- a/ooxml/XSSF/UserModel/XSSFChart.cs
+++ b/ooxml/XSSF/UserModel/XSSFChart.cs
@@ -166,14 +166,20 @@ internal void SetGraphicFrame(XSSFGraphicFrame frame)
             this.frame = frame;
         }
 
-        public IChartDataFactory GetChartDataFactory()
+        public IChartDataFactory ChartDataFactory
         {
-            return XSSFChartDataFactory.GetInstance();
+            get
+            {
+                return XSSFChartDataFactory.GetInstance();
+            }
         }
 
-        public IChartAxisFactory GetChartAxisFactory()
+        public IChartAxisFactory ChartAxisFactory
         {
-            return this;
+            get
+            {
+                return this;
+            }
         }
 
         public void Plot(IChartData data, params IChartAxis[] axis)
diff --git a/testcases/ooxml/OOXML.Testcases vs2010.csproj b/testcases/ooxml/OOXML.Testcases vs2010.csproj
index 1e1ac0b3d..894a429d9 100644
--- a/testcases/ooxml/OOXML.Testcases vs2010.csproj	
+++ b/testcases/ooxml/OOXML.Testcases vs2010.csproj	
@@ -118,6 +118,7 @@
     <Compile Include="XSSF\UserModel\Charts\TestXSSFCategoryAxis.cs" />
     <Compile Include="XSSF\UserModel\Charts\TestXSSFChartAxis.cs" />
     <Compile Include="XSSF\UserModel\Charts\TestXSSFChartLegend.cs" />
+    <Compile Include="XSSF\UserModel\Charts\TestXSSFLineChartData.cs" />
     <Compile Include="XSSF\UserModel\Charts\TestXSSFManualLayout.cs" />
     <Compile Include="XSSF\UserModel\Charts\TestXSSFScatterChartData.cs" />
     <Compile Include="XSSF\UserModel\Charts\TestXSSFValueAxis.cs" />
diff --git a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFCategoryAxis.cs b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFCategoryAxis.cs
index 359b3e7c8..c214b1b64 100644
--- a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFCategoryAxis.cs
+++ b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFCategoryAxis.cs
@@ -36,10 +36,10 @@ public void TestAccessMethods()
             XSSFDrawing Drawing = sheet.CreateDrawingPatriarch() as XSSFDrawing;
             XSSFClientAnchor anchor = Drawing.CreateAnchor(0, 0, 0, 0, 1, 1, 10, 30) as XSSFClientAnchor;
             XSSFChart chart = Drawing.CreateChart(anchor) as XSSFChart;
-            XSSFCategoryAxis axis = chart.GetChartAxisFactory().CreateCategoryAxis(AxisPosition.Bottom) as XSSFCategoryAxis;
+            XSSFCategoryAxis axis = chart.ChartAxisFactory.CreateCategoryAxis(AxisPosition.Bottom) as XSSFCategoryAxis;
 
-            axis.SetCrosses(AxisCrosses.AutoZero);
-            Assert.AreEqual(axis.GetCrosses(), AxisCrosses.AutoZero);
+            axis.Crosses=(AxisCrosses.AutoZero);
+            Assert.AreEqual(axis.Crosses, AxisCrosses.AutoZero);
 
             Assert.AreEqual(chart.GetAxis().Count, 1);
         }
diff --git a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFChartAxis.cs b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFChartAxis.cs
index 4353df511..6c525a204 100644
--- a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFChartAxis.cs
+++ b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFChartAxis.cs
@@ -35,7 +35,7 @@ public TestXSSFChartAxis()
             IDrawing Drawing = sheet.CreateDrawingPatriarch();
             IClientAnchor anchor = Drawing.CreateAnchor(0, 0, 0, 0, 1, 1, 10, 30);
             IChart chart = Drawing.CreateChart(anchor);
-            axis = chart.GetChartAxisFactory().CreateValueAxis(AxisPosition.Bottom);
+            axis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Bottom);
         }
         [Test]
         public void TestLogBaseIllegalArgument()
@@ -43,7 +43,7 @@ public void TestLogBaseIllegalArgument()
             ArgumentException iae = null;
             try
             {
-                axis.SetLogBase(0.0);
+                axis.LogBase=(0.0);
             }
             catch (ArgumentException e)
             {
@@ -54,7 +54,7 @@ public void TestLogBaseIllegalArgument()
             iae = null;
             try
             {
-                axis.SetLogBase(30000.0);
+                axis.LogBase=(30000.0);
             }
             catch (ArgumentException e)
             {
@@ -65,26 +65,67 @@ public void TestLogBaseIllegalArgument()
         [Test]
         public void TestLogBaseLegalArgument()
         {
-            axis.SetLogBase(Math.E);
-            Assert.IsTrue(Math.Abs(axis.GetLogBase() - Math.E) < EPSILON);
+            axis.LogBase=(Math.E);
+            Assert.IsTrue(Math.Abs(axis.LogBase - Math.E) < EPSILON);
         }
         [Test]
         public void TestNumberFormat()
         {
             String numberFormat = "General";
-            axis.SetNumberFormat(numberFormat);
-            Assert.AreEqual(numberFormat, axis.GetNumberFormat());
+            axis.NumberFormat=(numberFormat);
+            Assert.AreEqual(numberFormat, axis.NumberFormat);
         }
         [Test]
         public void TestMaxAndMinAccessMethods()
         {
             double newValue = 10.0;
 
-            axis.SetMinimum(newValue);
-            Assert.IsTrue(Math.Abs(axis.GetMinimum() - newValue) < EPSILON);
+            axis.Minimum=(newValue);
+            Assert.IsTrue(Math.Abs(axis.Minimum - newValue) < EPSILON);
 
-            axis.SetMaximum(newValue);
-            Assert.IsTrue(Math.Abs(axis.GetMaximum() - newValue) < EPSILON);
+            axis.Maximum=(newValue);
+            Assert.IsTrue(Math.Abs(axis.Maximum - newValue) < EPSILON);
+        }
+        [Test]
+        public void TestVisibleAccessMethods()
+        {
+            axis.IsVisible = (/*setter*/true);
+            Assert.IsTrue(axis.IsVisible);
+
+            axis.IsVisible = (/*setter*/false);
+            Assert.IsFalse(axis.IsVisible);
+        }
+
+        [Test]
+        public void TestMajorTickMarkAccessMethods()
+        {
+            axis.MajorTickMark = (/*setter*/AxisTickMark.None);
+            Assert.AreEqual(AxisTickMark.None, axis.MajorTickMark);
+
+            axis.MajorTickMark = (/*setter*/AxisTickMark.In);
+            Assert.AreEqual(AxisTickMark.In, axis.MajorTickMark);
+
+            axis.MajorTickMark = (/*setter*/AxisTickMark.Out);
+            Assert.AreEqual(AxisTickMark.Out, axis.MajorTickMark);
+
+            axis.MajorTickMark = (/*setter*/AxisTickMark.Cross);
+            Assert.AreEqual(AxisTickMark.Cross, axis.MajorTickMark);
+        }
+
+        [Test]
+        public void TestMinorTickMarkAccessMethods()
+        {
+            axis.MinorTickMark = (/*setter*/AxisTickMark.None);
+            Assert.AreEqual(AxisTickMark.None, axis.MinorTickMark);
+
+            axis.MinorTickMark = (/*setter*/AxisTickMark.In);
+            Assert.AreEqual(AxisTickMark.In, axis.MinorTickMark);
+
+            axis.MinorTickMark = (/*setter*/AxisTickMark.Out);
+            Assert.AreEqual(AxisTickMark.Out, axis.MinorTickMark);
+
+            axis.MinorTickMark = (/*setter*/AxisTickMark.Cross);
+            Assert.AreEqual(AxisTickMark.Cross, axis.MinorTickMark);
         }
 
     }
diff --git a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFLineChartData.cs b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFLineChartData.cs
new file mode 100644
index 000000000..aef9573ef
--- /dev/null
+++ b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFLineChartData.cs
@@ -0,0 +1,52 @@
+namespace NPOI.XSSF.UserModel.Charts
+{
+    using System;
+
+    using NUnit.Framework;
+    using NPOI.SS.UserModel;
+    using NPOI.SS.UserModel.Charts;
+    using NPOI.SS.Util;
+    using NPOI.XSSF.UserModel;
+
+    /**
+     * @author Martin Andersson
+     */
+    [TestFixture]
+    public class TestXSSFLineChartData
+    {
+        [SetUp]
+        public void Setup()
+        {
+            plotData[0] = new string[] {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J"};
+            plotData[1] = new object[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+        }
+        private object[][] plotData = new object[2][];
+
+        [Test]
+        public void TestOneSeriePlot()
+        {
+            IWorkbook wb = new XSSFWorkbook();
+            ISheet sheet = new SheetBuilder(wb, plotData).Build();
+            IDrawing Drawing = sheet.CreateDrawingPatriarch();
+            IClientAnchor anchor = Drawing.CreateAnchor(0, 0, 0, 0, 1, 1, 10, 30);
+            IChart chart = Drawing.CreateChart(anchor);
+
+            IChartAxis bottomAxis = chart.ChartAxisFactory.CreateCategoryAxis(AxisPosition.Bottom);
+            IChartAxis leftAxis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Left);
+
+            ILineChartData<string, double> lineChartData =
+                    chart.ChartDataFactory.CreateLineChartData<string, double>();
+
+            IChartDataSource<String> xs = DataSources.FromStringCellRange(sheet, CellRangeAddress.ValueOf("A1:J1"));
+            IChartDataSource<double> ys = DataSources.FromNumericCellRange(sheet, CellRangeAddress.ValueOf("A2:J2"));
+            ILineChartSerie<string, double> serie = lineChartData.AddSerie(xs, ys);
+
+            Assert.IsNotNull(serie);
+            Assert.AreEqual(1, lineChartData.GetSeries().Count);
+            Assert.IsTrue(lineChartData.GetSeries().Contains(serie));
+
+            chart.Plot(lineChartData, bottomAxis, leftAxis);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFScatterChartData.cs b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFScatterChartData.cs
index eb3e1b94a..795cfe0a2 100644
--- a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFScatterChartData.cs
+++ b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFScatterChartData.cs
@@ -43,11 +43,11 @@ public void TestOneSeriePlot()
             IClientAnchor anchor = Drawing.CreateAnchor(0, 0, 0, 0, 1, 1, 10, 30);
             IChart chart = Drawing.CreateChart(anchor);
 
-            IChartAxis bottomAxis = chart.GetChartAxisFactory().CreateValueAxis(AxisPosition.Bottom);
-            IChartAxis leftAxis = chart.GetChartAxisFactory().CreateValueAxis(AxisPosition.Left);
+            IChartAxis bottomAxis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Bottom);
+            IChartAxis leftAxis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Left);
 
             IScatterChartData<string, double> scatterChartData =
-                chart.GetChartDataFactory().CreateScatterChartData<string, double>();
+                chart.ChartDataFactory.CreateScatterChartData<string, double>();
 
             IChartDataSource<String> xs = DataSources.FromStringCellRange(sheet, CellRangeAddress.ValueOf("A1:J1"));
             IChartDataSource<double> ys = DataSources.FromNumericCellRange(sheet, CellRangeAddress.ValueOf("A2:J2"));
diff --git a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFValueAxis.cs b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFValueAxis.cs
index 050178dde..2cb7e2f8a 100644
--- a/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFValueAxis.cs
+++ b/testcases/ooxml/XSSF/UserModel/Charts/TestXSSFValueAxis.cs
@@ -33,13 +33,13 @@ public void TestAccessMethods()
             IDrawing Drawing = sheet.CreateDrawingPatriarch();
             IClientAnchor anchor = Drawing.CreateAnchor(0, 0, 0, 0, 1, 1, 10, 30);
             IChart chart = Drawing.CreateChart(anchor);
-            IValueAxis axis = chart.GetChartAxisFactory().CreateValueAxis(AxisPosition.Bottom);
+            IValueAxis axis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Bottom);
 
             axis.SetCrossBetween(AxisCrossBetween.MidpointCategory);
             Assert.AreEqual(axis.GetCrossBetween(), AxisCrossBetween.MidpointCategory);
 
-            axis.SetCrosses(AxisCrosses.AutoZero);
-            Assert.AreEqual(axis.GetCrosses(), AxisCrosses.AutoZero);
+            axis.Crosses=(AxisCrosses.AutoZero);
+            Assert.AreEqual(axis.Crosses, AxisCrosses.AutoZero);
 
             Assert.AreEqual(chart.GetAxis().Count, 1);
         }