/*
     Licensed to the Apache Software Foundation (ASF) under one or more
     contributor license agreements.  See the NOTICE file distributed with
     this work for additional information regarding copyright ownership.
     The ASF licenses this file to You 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.apache.commons.cli;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  import static org.junit.jupiter.api.Assertions.fail;
  
  import org.junit.jupiter.api.Test;
  
  @SuppressWarnings("deprecation") // OptionBuilder is marked deprecated
  public class OptionBuilderTest {
      @Test
      public void testBaseOptionCharOpt() {
          final Option base = OptionBuilder.withDescription("option description").create('o');
  
          assertEquals("o", base.getOpt());
          assertEquals("option description", base.getDescription());
          assertFalse(base.hasArg());
      }
  
      @Test
      public void testBaseOptionStringOpt() {
          final Option base = OptionBuilder.withDescription("option description").create("o");
  
          assertEquals("o", base.getOpt());
          assertEquals("option description", base.getDescription());
          assertFalse(base.hasArg());
      }
  
      @Test
      public void testBuilderIsResettedAlways() {
          try {
              OptionBuilder.withDescription("JUnit").create('"');
              fail("IllegalArgumentException expected");
          } catch (final IllegalArgumentException e) {
              // expected
          }
          assertNull(OptionBuilder.create('x').getDescription(), "we inherited a description");
  
          try {
              OptionBuilder.withDescription("JUnit").create();
              fail("IllegalArgumentException expected");
          } catch (final IllegalArgumentException e) {
              // expected
          }
          assertNull(OptionBuilder.create('x').getDescription(), "we inherited a description");
      }
  
      @Test
      public void testCompleteOption() {
          //@formatter:off
          final Option simple = OptionBuilder.withLongOpt("simple option")
                                       .hasArg()
                                       .isRequired()
                                       .hasArgs()
                                       .withType(Float.class)
                                       .withDescription("this is a simple option")
                                       .create('s');
          //@formatter:on
  
          assertEquals("s", simple.getOpt());
          assertEquals("simple option", simple.getLongOpt());
          assertEquals("this is a simple option", simple.getDescription());
          assertEquals(simple.getType(), Float.class);
          assertTrue(simple.hasArg());
          assertTrue(simple.isRequired());
          assertTrue(simple.hasArgs());
      }
  
      @Test
      public void testCreateIncompleteOption() {
          try {
              OptionBuilder.hasArg().create();
              fail("Incomplete option should be rejected");
          } catch (final IllegalArgumentException e) {
              // expected
  
              // implicitly reset the builder
              OptionBuilder.create("opt");
          }
      }
 
     @Test
     public void testIllegalOptions() {
         // bad single character option
         try {
             OptionBuilder.withDescription("option description").create('"');
             fail("IllegalArgumentException not caught");
         } catch (final IllegalArgumentException exp) {
             // success
         }
 
         // bad character in option string
         try {
             OptionBuilder.create("opt`");
             fail("IllegalArgumentException not caught");
         } catch (final IllegalArgumentException exp) {
             // success
         }
 
         // valid option
         try {
             OptionBuilder.create("opt");
             // success
         } catch (final IllegalArgumentException exp) {
             fail("IllegalArgumentException caught");
         }
     }
 
     @Test
     public void testOptionArgNumbers() {
         //@formatter:off
         final Option opt = OptionBuilder.withDescription("option description")
                                   .hasArgs(2)
                                   .create('o');
         //@formatter:on
         assertEquals(2, opt.getArgs());
     }
 
     @Test
     public void testSpecialOptChars() throws Exception {
         // '?'
         final Option opt1 = OptionBuilder.withDescription("help options").create('?');
         assertEquals("?", opt1.getOpt());
 
         // '@'
         final Option opt2 = OptionBuilder.withDescription("read from stdin").create('@');
         assertEquals("@", opt2.getOpt());
 
         // ' '
         try {
             OptionBuilder.create(' ');
             fail("IllegalArgumentException not caught");
         } catch (final IllegalArgumentException e) {
             // success
         }
     }
 
     @Test
     public void testTwoCompleteOptions() {
         //@formatter:off
         Option simple = OptionBuilder.withLongOpt("simple option")
                                      .hasArg()
                                      .isRequired()
                                      .hasArgs()
                                      .withType(Float.class)
                                      .withDescription("this is a simple option")
                                      .create('s');
         //@formatter:on
 
         assertEquals("s", simple.getOpt());
         assertEquals("simple option", simple.getLongOpt());
         assertEquals("this is a simple option", simple.getDescription());
         assertEquals(simple.getType(), Float.class);
         assertTrue(simple.hasArg());
         assertTrue(simple.isRequired());
         assertTrue(simple.hasArgs());
 
         //@formatter:off
         simple = OptionBuilder.withLongOpt("dimple option")
                               .hasArg()
                               .withDescription("this is a dimple option")
                               .create('d');
         //@formatter:on
 
         assertEquals("d", simple.getOpt());
         assertEquals("dimple option", simple.getLongOpt());
         assertEquals("this is a dimple option", simple.getDescription());
         assertEquals(String.class, simple.getType());
         assertTrue(simple.hasArg());
         assertFalse(simple.isRequired());
         assertFalse(simple.hasArgs());
     }
 }