/*
 * ARX Data Anonymization Tool
 * Copyright 2012 - 2024 Fabian Prasser and contributors
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.deidentifier.arx.test;

import java.io.IOException;

import org.deidentifier.arx.examples.Example1;
import org.deidentifier.arx.examples.Example10;
import org.deidentifier.arx.examples.Example11;
import org.deidentifier.arx.examples.Example12;
import org.deidentifier.arx.examples.Example13;
import org.deidentifier.arx.examples.Example14;
import org.deidentifier.arx.examples.Example16;
import org.deidentifier.arx.examples.Example17;
import org.deidentifier.arx.examples.Example18;
import org.deidentifier.arx.examples.Example19;
import org.deidentifier.arx.examples.Example2;
import org.deidentifier.arx.examples.Example20;
import org.deidentifier.arx.examples.Example21;
import org.deidentifier.arx.examples.Example22;
import org.deidentifier.arx.examples.Example23;
import org.deidentifier.arx.examples.Example24;
import org.deidentifier.arx.examples.Example25;
import org.deidentifier.arx.examples.Example26;
import org.deidentifier.arx.examples.Example27;
import org.deidentifier.arx.examples.Example28;
import org.deidentifier.arx.examples.Example29;
import org.deidentifier.arx.examples.Example3;
import org.deidentifier.arx.examples.Example30;
import org.deidentifier.arx.examples.Example31;
import org.deidentifier.arx.examples.Example32;
import org.deidentifier.arx.examples.Example33;
import org.deidentifier.arx.examples.Example34;
import org.deidentifier.arx.examples.Example35;
import org.deidentifier.arx.examples.Example36;
import org.deidentifier.arx.examples.Example37;
import org.deidentifier.arx.examples.Example38;
import org.deidentifier.arx.examples.Example39;
import org.deidentifier.arx.examples.Example4;
import org.deidentifier.arx.examples.Example40;
import org.deidentifier.arx.examples.Example41;
import org.deidentifier.arx.examples.Example42;
import org.deidentifier.arx.examples.Example43;
import org.deidentifier.arx.examples.Example44;
import org.deidentifier.arx.examples.Example45;
import org.deidentifier.arx.examples.Example46;
import org.deidentifier.arx.examples.Example47;
import org.deidentifier.arx.examples.Example48;
import org.deidentifier.arx.examples.Example49;
import org.deidentifier.arx.examples.Example5;
import org.deidentifier.arx.examples.Example50;
import org.deidentifier.arx.examples.Example51;
import org.deidentifier.arx.examples.Example52;
import org.deidentifier.arx.examples.Example53;
import org.deidentifier.arx.examples.Example54;
import org.deidentifier.arx.examples.Example55;
import org.deidentifier.arx.examples.Example56;
import org.deidentifier.arx.examples.Example57;
import org.deidentifier.arx.examples.Example6;
import org.deidentifier.arx.examples.Example7;
import org.deidentifier.arx.examples.Example8;
import org.deidentifier.arx.examples.Example9;
import org.junit.Assert;
import org.junit.Test;

/**
 * Perform unit test based on the examples
 * 
 * @author Fabian Prasser
 * @author Florian Kohlmayer
 */
public class TestExamples {
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample1() {
        try {
            Example1.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample10() {
        try {
            Example10.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample11() {
        try {
            Example11.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample12() {
        try {
            Example12.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample13() {
        try {
            Example13.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample14() {
        try {
            Example14.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample16() {
        try {
            Example16.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample17() {
        try {
            Example17.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample18() {
        try {
            Example18.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample19() {
        try {
            Example19.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     *
     * Perform unit test based on the example@throws IOException
     */
    @Test
    public void testExample2() throws IOException {
        try {
            Example2.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample20() {
        try {
            Example20.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample21() {
        try {
            Example21.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample22() {
        try {
            Example22.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample23() {
        try {
            Example23.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample24() {
        try {
            Example24.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample25() {
        try {
            Example25.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample26() {
        try {
            Example26.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample27() {
        try {
            Example27.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample28() {
        try {
            Example28.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample29() {
        try {
            Example29.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample3() {
        try {
            Example3.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample30() {
        try {
            Example30.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample31() {
        try {
            Example31.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample32() {
        try {
            Example32.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample33() {
        try {
            Example33.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample34() {
        try {
            Example34.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample35() {
        try {
            Example35.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample36() {
        try {
            Example36.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample37() {
        try {
            Example37.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample38() {
        try {
            Example38.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample39() {
        try {
            Example39.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample4() {
        try {
            Example4.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample40() {
        try {
            Example40.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample41() {
        try {
            Example41.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample42() {
        try {
            Example42.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample43() {
        try {
            Example43.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample44() {
        try {
            Example44.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample45() {
        try {
            Example45.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample46() {
        try {
            Example46.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample47() {
        try {
            Example47.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample48() {
        try {
            Example48.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample49() {
        try {
            Example49.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample50() {
        try {
            Example50.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample51() {
        try {
            Example51.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample52() {
        try {
            Example52.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample53() {
        try {
            Example53.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample54() {
        try {
            Example54.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample55() {
        try {
            Example55.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample56() {
        try {
            Example56.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }

    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample57() {
        try {
            Example57.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample5() {
        try {
            Example5.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample6() {
        try {
            Example6.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample7() {
        try {
            Example7.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample8() {
        try {
            Example8.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
    
    /**
     * Perform unit test based on the example
     */
    @Test
    public void testExample9() {
        try {
            Example9.main(null);
        } catch (final Exception e) {
            e.printStackTrace();
            Assert.fail();
        }
    }
}
