# PiePlotTests.java

    /* ===========================================================
     * JFreeChart : a free chart library for the Java(tm) platform
     * ===========================================================
     *
     * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
     *
     * Project Info:  http://www.jfree.org/jfreechart/index.html
     *
     * This library is free software; you can redistribute it and/or modify it
     * under the terms of the GNU Lesser General Public License as published by
     * the Free Software Foundation; either version 2.1 of the License, or
     * (at your option) any later version.
     *
     * This library is distributed in the hope that it will be useful, but
     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
     * License for more details.
     *
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
     * USA.
     *
     * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
     * in the United States and other countries.]
     *
     * -----------------
     * PiePlotTests.java
     * -----------------
     * (C) Copyright 2003-2008, by Object Refinery Limited and Contributors.
     *
     * Original Author:  David Gilbert (for Object Refinery Limited);
     * Contributor(s):   -;
     *
     * Changes
     * -------
     * 18-Mar-2003 : Version 1 (DG);
     * 10-May-2005 : Strengthened equals() test (DG);
     * 27-Sep-2006 : Added tests for the getBaseSectionPaint() method (DG);
     * 23-Nov-2006 : Additional equals() and clone() tests (DG);
     * 17-Apr-2007 : Added check for label generator that returns a null label (DG);
     * 31-Mar-2008 : Updated testEquals();
     *
     */

    package org.jfree.chart.plot.junit;

    import java.awt.BasicStroke;
    import java.awt.Color;
    import java.awt.Font;
    import java.awt.GradientPaint;
    import java.awt.Graphics2D;
    import java.awt.Rectangle;
    import java.awt.Stroke;
    import java.awt.geom.Rectangle2D;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInput;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutput;
    import java.io.ObjectOutputStream;
    import java.text.AttributedString;

    import junit.framework.Test;
    import junit.framework.TestCase;
    import junit.framework.TestSuite;

    import org.jfree.chart.ChartFactory;
    import org.jfree.chart.JFreeChart;
    import org.jfree.chart.LegendItemCollection;
    import org.jfree.chart.labels.PieSectionLabelGenerator;
    import org.jfree.chart.labels.StandardPieSectionLabelGenerator;
    import org.jfree.chart.labels.StandardPieToolTipGenerator;
    import org.jfree.chart.plot.PieLabelLinkStyle;
    import org.jfree.chart.plot.PiePlot;
    import org.jfree.chart.urls.CustomPieURLGenerator;
    import org.jfree.chart.urls.StandardPieURLGenerator;
    import org.jfree.data.general.DefaultPieDataset;
    import org.jfree.data.general.PieDataset;
    import org.jfree.util.Rotation;

    /**
     * Some tests for the {@link PiePlot} class.
     */
    public class PiePlotTests extends TestCase {

        /**
         * Returns the tests as a test suite.
         *
         * @return The test suite.
         */
        public static Test suite() {
            return new TestSuite(PiePlotTests.class);
        }

        /**
         * Constructs a new set of tests.
         *
         * @param name  the name of the tests.
         */
        public PiePlotTests(String name) {
            super(name);
        }

        /**
         * Test the equals() method.
         */
        public void testEquals() {

            PiePlot plot1 = new PiePlot();
            PiePlot plot2 = new PiePlot();
            assertTrue(plot1.equals(plot2));
            assertTrue(plot2.equals(plot1));

            // pieIndex...
            plot1.setPieIndex(99);
            assertFalse(plot1.equals(plot2));
            plot2.setPieIndex(99);
            assertTrue(plot1.equals(plot2));

            // interiorGap...
            plot1.setInteriorGap(0.15);
            assertFalse(plot1.equals(plot2));
            plot2.setInteriorGap(0.15);
            assertTrue(plot1.equals(plot2));

            // circular
            plot1.setCircular(!plot1.isCircular());
            assertFalse(plot1.equals(plot2));
            plot2.setCircular(false);
            assertTrue(plot1.equals(plot2));

            // startAngle
            plot1.setStartAngle(Math.PI);
            assertFalse(plot1.equals(plot2));
            plot2.setStartAngle(Math.PI);
            assertTrue(plot1.equals(plot2));

            // direction
            plot1.setDirection(Rotation.ANTICLOCKWISE);
            assertFalse(plot1.equals(plot2));
            plot2.setDirection(Rotation.ANTICLOCKWISE);
            assertTrue(plot1.equals(plot2));

            // ignoreZeroValues
            plot1.setIgnoreZeroValues(true);
            plot2.setIgnoreZeroValues(false);
            assertFalse(plot1.equals(plot2));
            plot2.setIgnoreZeroValues(true);
            assertTrue(plot1.equals(plot2));

            // ignoreNullValues
            plot1.setIgnoreNullValues(true);
            plot2.setIgnoreNullValues(false);
            assertFalse(plot1.equals(plot2));
            plot2.setIgnoreNullValues(true);
            assertTrue(plot1.equals(plot2));

            // sectionPaint
            plot1.setSectionPaint(new GradientPaint(1.0f, 2.0f, Color.red,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setSectionPaint(new GradientPaint(1.0f, 2.0f, Color.red,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // sectionPaintMap
            plot1.setSectionPaint("A", new GradientPaint(1.0f, 2.0f, Color.blue,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setSectionPaint("A", new GradientPaint(1.0f, 2.0f, Color.blue,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // baseSectionPaint
            plot1.setBaseSectionPaint(new GradientPaint(1.0f, 2.0f, Color.black,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setBaseSectionPaint(new GradientPaint(1.0f, 2.0f, Color.black,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // sectionOutlinesVisible
            plot1.setSectionOutlinesVisible(false);
            assertFalse(plot1.equals(plot2));
            plot2.setSectionOutlinesVisible(false);
            assertTrue(plot1.equals(plot2));

            // sectionOutlinePaint
            plot1.setSectionOutlinePaint(new GradientPaint(1.0f, 2.0f, Color.cyan,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setSectionOutlinePaint(new GradientPaint(1.0f, 2.0f, Color.cyan,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // sectionOutlinePaintList
            plot1.setSectionOutlinePaint("A", new GradientPaint(1.0f, 2.0f,
                    Color.green, 3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setSectionOutlinePaint("A", new GradientPaint(1.0f, 2.0f,
                    Color.green, 3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // baseSectionOutlinePaint
            plot1.setBaseSectionOutlinePaint(new GradientPaint(1.0f, 2.0f,
                    Color.gray, 3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setBaseSectionOutlinePaint(new GradientPaint(1.0f, 2.0f,
                    Color.gray, 3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // sectionOutlineStroke
            plot1.setSectionOutlineStroke(new BasicStroke(1.0f));
            assertFalse(plot1.equals(plot2));
            plot2.setSectionOutlineStroke(new BasicStroke(1.0f));
            assertTrue(plot1.equals(plot2));

            // sectionOutlineStrokeList
            plot1.setSectionOutlineStroke("A", new BasicStroke(1.0f));
            assertFalse(plot1.equals(plot2));
            plot2.setSectionOutlineStroke("A", new BasicStroke(1.0f));
            assertTrue(plot1.equals(plot2));

            // baseSectionOutlineStroke
            plot1.setBaseSectionOutlineStroke(new BasicStroke(1.0f));
            assertFalse(plot1.equals(plot2));
            plot2.setBaseSectionOutlineStroke(new BasicStroke(1.0f));
            assertTrue(plot1.equals(plot2));

            // shadowPaint
            plot1.setShadowPaint(new GradientPaint(1.0f, 2.0f, Color.orange,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setShadowPaint(new GradientPaint(1.0f, 2.0f, Color.orange,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // shadowXOffset
            plot1.setShadowXOffset(4.4);
            assertFalse(plot1.equals(plot2));
            plot2.setShadowXOffset(4.4);
            assertTrue(plot1.equals(plot2));

            // shadowYOffset
            plot1.setShadowYOffset(4.4);
            assertFalse(plot1.equals(plot2));
            plot2.setShadowYOffset(4.4);
            assertTrue(plot1.equals(plot2));

            // labelFont
            plot1.setLabelFont(new Font("Serif", Font.PLAIN, 18));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelFont(new Font("Serif", Font.PLAIN, 18));
            assertTrue(plot1.equals(plot2));

            // labelPaint
            plot1.setLabelPaint(new GradientPaint(1.0f, 2.0f, Color.darkGray,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelPaint(new GradientPaint(1.0f, 2.0f, Color.darkGray,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // labelBackgroundPaint
            plot1.setLabelBackgroundPaint(new GradientPaint(1.0f, 2.0f, Color.red,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelBackgroundPaint(new GradientPaint(1.0f, 2.0f, Color.red,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // labelOutlinePaint
            plot1.setLabelOutlinePaint(new GradientPaint(1.0f, 2.0f, Color.blue,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelOutlinePaint(new GradientPaint(1.0f, 2.0f, Color.blue,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // labelOutlineStroke
            Stroke s = new BasicStroke(1.1f);
            plot1.setLabelOutlineStroke(s);
            assertFalse(plot1.equals(plot2));
            plot2.setLabelOutlineStroke(s);
            assertTrue(plot1.equals(plot2));

            // labelShadowPaint
            plot1.setLabelShadowPaint(new GradientPaint(1.0f, 2.0f, Color.yellow,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelShadowPaint(new GradientPaint(1.0f, 2.0f, Color.yellow,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // explodePercentages
            plot1.setExplodePercent("A", 0.33);
            assertFalse(plot1.equals(plot2));
            plot2.setExplodePercent("A", 0.33);
            assertTrue(plot1.equals(plot2));

            // labelGenerator
            plot1.setLabelGenerator(new StandardPieSectionLabelGenerator(
                    "{2}{1}{0}"));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelGenerator(new StandardPieSectionLabelGenerator(
                    "{2}{1}{0}"));
            assertTrue(plot1.equals(plot2));

            // labelFont
            Font f = new Font("SansSerif", Font.PLAIN, 20);
            plot1.setLabelFont(f);
            assertFalse(plot1.equals(plot2));
            plot2.setLabelFont(f);
            assertTrue(plot1.equals(plot2));

            // labelPaint
            plot1.setLabelPaint(new GradientPaint(1.0f, 2.0f, Color.magenta,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelPaint(new GradientPaint(1.0f, 2.0f, Color.magenta,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // maximumLabelWidth
            plot1.setMaximumLabelWidth(0.33);
            assertFalse(plot1.equals(plot2));
            plot2.setMaximumLabelWidth(0.33);
            assertTrue(plot1.equals(plot2));

            // labelGap
            plot1.setLabelGap(0.11);
            assertFalse(plot1.equals(plot2));
            plot2.setLabelGap(0.11);
            assertTrue(plot1.equals(plot2));

            // links visible
            plot1.setLabelLinksVisible(false);
            assertFalse(plot1.equals(plot2));
            plot2.setLabelLinksVisible(false);
            assertTrue(plot1.equals(plot2));

            plot1.setLabelLinkStyle(PieLabelLinkStyle.QUAD_CURVE);
            assertFalse(plot1.equals(plot2));
            plot2.setLabelLinkStyle(PieLabelLinkStyle.QUAD_CURVE);
            assertTrue(plot1.equals(plot2));

            // linkMargin
            plot1.setLabelLinkMargin(0.11);
            assertFalse(plot1.equals(plot2));
            plot2.setLabelLinkMargin(0.11);
            assertTrue(plot1.equals(plot2));

            // labelLinkPaint
            plot1.setLabelLinkPaint(new GradientPaint(1.0f, 2.0f, Color.magenta,
                    3.0f, 4.0f, Color.white));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelLinkPaint(new GradientPaint(1.0f, 2.0f, Color.magenta,
                    3.0f, 4.0f, Color.white));
            assertTrue(plot1.equals(plot2));

            // labelLinkStroke
            plot1.setLabelLinkStroke(new BasicStroke(1.0f));
            assertFalse(plot1.equals(plot2));
            plot2.setLabelLinkStroke(new BasicStroke(1.0f));
            assertTrue(plot1.equals(plot2));

            // toolTipGenerator
            plot1.setToolTipGenerator(
                new StandardPieToolTipGenerator("{2}{1}{0}")
            );
            assertFalse(plot1.equals(plot2));
            plot2.setToolTipGenerator(
                new StandardPieToolTipGenerator("{2}{1}{0}")
            );
            assertTrue(plot1.equals(plot2));

            // urlGenerator
            plot1.setURLGenerator(new StandardPieURLGenerator("xx"));
            assertFalse(plot1.equals(plot2));
            plot2.setURLGenerator(new StandardPieURLGenerator("xx"));
            assertTrue(plot1.equals(plot2));

            // minimumArcAngleToDraw
            plot1.setMinimumArcAngleToDraw(1.0);
            assertFalse(plot1.equals(plot2));
            plot2.setMinimumArcAngleToDraw(1.0);
            assertTrue(plot1.equals(plot2));

            // legendItemShape
            plot1.setLegendItemShape(new Rectangle2D.Double(1.0, 2.0, 3.0, 4.0));
            assertFalse(plot1.equals(plot2));
            plot2.setLegendItemShape(new Rectangle2D.Double(1.0, 2.0, 3.0, 4.0));
            assertTrue(plot1.equals(plot2));

            // legendLabelGenerator
            plot1.setLegendLabelGenerator(new StandardPieSectionLabelGenerator(
                    "{0} --> {1}"));
            assertFalse(plot1.equals(plot2));
            plot2.setLegendLabelGenerator(new StandardPieSectionLabelGenerator(
                    "{0} --> {1}"));
            assertTrue(plot1.equals(plot2));

            // legendLabelToolTipGenerator
            plot1.setLegendLabelToolTipGenerator(
                    new StandardPieSectionLabelGenerator("{0} is {1}"));
            assertFalse(plot1.equals(plot2));
            plot2.setLegendLabelToolTipGenerator(
                    new StandardPieSectionLabelGenerator("{0} is {1}"));
            assertTrue(plot1.equals(plot2));

            // legendLabelURLGenerator
            plot1.setLegendLabelURLGenerator(new StandardPieURLGenerator(
                    "index.html"));
            assertFalse(plot1.equals(plot2));
            plot2.setLegendLabelURLGenerator(new StandardPieURLGenerator(
                    "index.html"));
            assertTrue(plot1.equals(plot2));

        }

        /**
         * Some basic checks for the clone() method.
         */
        public void testCloning() {
            PiePlot p1 = new PiePlot();
            PiePlot p2 = null;
            try {
                p2 = (PiePlot) p1.clone();
            }
            catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            assertTrue(p1 != p2);
            assertTrue(p1.getClass() == p2.getClass());
            assertTrue(p1.equals(p2));
        }

        /**
         * Check cloning of the urlGenerator field.
         */
        public void testCloning_URLGenerator() {
            CustomPieURLGenerator generator = new CustomPieURLGenerator();
            PiePlot p1 = new PiePlot();
            p1.setURLGenerator(generator);
            PiePlot p2 = null;
            try {
                p2 = (PiePlot) p1.clone();
            }
            catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            assertTrue(p1 != p2);
            assertTrue(p1.getClass() == p2.getClass());
            assertTrue(p1.equals(p2));

            // check that the URL generator has been cloned
            assertTrue(p1.getURLGenerator() != p2.getURLGenerator());
        }

        /**
         * Check cloning of the legendItemShape field.
         */
        public void testCloning_LegendItemShape() {
            Rectangle shape = new Rectangle(-4, -4, 8, 8);
            PiePlot p1 = new PiePlot();
            p1.setLegendItemShape(shape);
            PiePlot p2 = null;
            try {
                p2 = (PiePlot) p1.clone();
            }
            catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            assertTrue(p1 != p2);
            assertTrue(p1.getClass() == p2.getClass());
            assertTrue(p1.equals(p2));

            // change the shape and make sure it only affects p1
            shape.setRect(1.0, 2.0, 3.0, 4.0);
            assertFalse(p1.equals(p2));
        }

        /**
         * Check cloning of the legendLabelGenerator field.
         */
        public void testCloning_LegendLabelGenerator() {
            StandardPieSectionLabelGenerator generator
                    = new StandardPieSectionLabelGenerator();
            PiePlot p1 = new PiePlot();
            p1.setLegendLabelGenerator(generator);
            PiePlot p2 = null;
            try {
                p2 = (PiePlot) p1.clone();
            }
            catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            assertTrue(p1 != p2);
            assertTrue(p1.getClass() == p2.getClass());
            assertTrue(p1.equals(p2));

            // change the generator and make sure it only affects p1
            generator.getNumberFormat().setMinimumFractionDigits(2);
            assertFalse(p1.equals(p2));
        }

        /**
         * Check cloning of the legendLabelToolTipGenerator field.
         */
        public void testCloning_LegendLabelToolTipGenerator() {
            StandardPieSectionLabelGenerator generator
                    = new StandardPieSectionLabelGenerator();
            PiePlot p1 = new PiePlot();
            p1.setLegendLabelToolTipGenerator(generator);
            PiePlot p2 = null;
            try {
                p2 = (PiePlot) p1.clone();
            }
            catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            assertTrue(p1 != p2);
            assertTrue(p1.getClass() == p2.getClass());
            assertTrue(p1.equals(p2));

            // change the generator and make sure it only affects p1
            generator.getNumberFormat().setMinimumFractionDigits(2);
            assertFalse(p1.equals(p2));
        }

        /**
         * Check cloning of the legendLabelURLGenerator field.
         */
        public void testCloning_LegendLabelURLGenerator() {
            CustomPieURLGenerator generator = new CustomPieURLGenerator();
            PiePlot p1 = new PiePlot();
            p1.setLegendLabelURLGenerator(generator);
            PiePlot p2 = null;
            try {
                p2 = (PiePlot) p1.clone();
            }
            catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            assertTrue(p1 != p2);
            assertTrue(p1.getClass() == p2.getClass());
            assertTrue(p1.equals(p2));

            // check that the URL generator has been cloned
            assertTrue(p1.getLegendLabelURLGenerator()
                    != p2.getLegendLabelURLGenerator());
        }

        /**
         * Serialize an instance, restore it, and check for equality.
         */
        public void testSerialization() {
            PiePlot p1 = new PiePlot(null);
            PiePlot p2 = null;
            try {
                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                ObjectOutput out = new ObjectOutputStream(buffer);
                out.writeObject(p1);
                out.close();

                ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(
                        buffer.toByteArray()));
                p2 = (PiePlot) in.readObject();
                in.close();
            }
            catch (Exception e) {
                e.printStackTrace();
            }
            assertEquals(p1, p2);
        }

        /**
         * Some checks for the getLegendItems() method.
         */
        public void testGetLegendItems() {
            DefaultPieDataset dataset = new DefaultPieDataset();
            dataset.setValue("Item 1", 1.0);
            dataset.setValue("Item 2", 2.0);
            dataset.setValue("Item 3", 0.0);
            dataset.setValue("Item 4", null);

            PiePlot plot = new PiePlot(dataset);
            plot.setIgnoreNullValues(false);
            plot.setIgnoreZeroValues(false);
            LegendItemCollection items = plot.getLegendItems();
            assertEquals(4, items.getItemCount());

            // check that null items are ignored if requested
            plot.setIgnoreNullValues(true);
            items = plot.getLegendItems();
            assertEquals(3, items.getItemCount());

            // check that zero items are ignored if requested
            plot.setIgnoreZeroValues(true);
            items = plot.getLegendItems();
            assertEquals(2, items.getItemCount());

            // check that negative items are always ignored
            dataset.setValue("Item 5", -1.0);
            items = plot.getLegendItems();
            assertEquals(2, items.getItemCount());
        }

        /**
         * Check that the default base section paint is not null, and that you
         * can never set it to null.
         */
        public void testGetBaseSectionPaint() {
            PiePlot plot = new PiePlot();
            assertNotNull(plot.getBaseSectionPaint());

            boolean pass = false;
            try {
                plot.setBaseSectionPaint(null);
            }
            catch (IllegalArgumentException e) {
                pass = true;
            }
            assertTrue(pass);
        }

        static class NullLegendLabelGenerator implements PieSectionLabelGenerator {
            public AttributedString generateAttributedSectionLabel(
                    PieDataset dataset, Comparable key) {
                return null;
            }
            public String generateSectionLabel(PieDataset dataset, Comparable key) {
                return null;
            }
        }

        /**
         * Draws a pie chart where the label generator returns null.
         */
        public void testDrawWithNullLegendLabels() {
            DefaultPieDataset dataset = new DefaultPieDataset();
            dataset.setValue("L1", 12.0);
            dataset.setValue("L2", 11.0);
            JFreeChart chart = ChartFactory.createPieChart("Test", dataset, true,
                    false, false);
            PiePlot plot = (PiePlot) chart.getPlot();
            plot.setLegendLabelGenerator(new NullLegendLabelGenerator());
            boolean success = false;
            try {
                BufferedImage image = new BufferedImage(200 , 100,
                        BufferedImage.TYPE_INT_RGB);
                Graphics2D g2 = image.createGraphics();
                chart.draw(g2, new Rectangle2D.Double(0, 0, 200, 100), null, null);
                g2.dispose();
                success = true;
            }
            catch (Exception e) {
              success = false;
            }
            assertTrue(success);
        }

    }