AnnotationTest (opencsv 5.12.0 Test API)

java.lang.Object
- com.opencsv.bean.AnnotationTest

```
public class AnnotationTest
extends Object
```
This class tests all annotation-based mapping except TemporalAccessor-based types.

Author:

Andrew Rucker Jones

See Also:

TemporalTest

Constructor Summary

Constructors
Constructor and Description

AnnotationTest()

Constructors
Constructor and Description
`AnnotationTest()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`setSystemLocaleBackToDefault()`
`void`	`setSystemLocaleToValueNotGerman()`
`static void`	`storeSystemLocale()`
`void`	`testAnonymousHeaders()` "Anonymous headers" is a term someone came up with for empty headers.
`void`	`testBadConverter()`
`void`	`testBadDataExceptionsCapturedUnordered()`
`void`	`testCaptureByNameInvalidRegex()`
`void`	`testCaptureByNameRegexWithoutCaptureGroup()`
`void`	`testCaptureByPositionInvalidRegex()`
`void`	`testCaptureByPositionRegexWithoutCaptureGroup()`
`void`	`testCaptureWithNullField()`
`void`	`testCustomByNameWrappedPrimitiveDataTypeMismatch()` Tests mapping fields of a wrapped primitive destination object by `CsvCustomBindByName` with mismatching types.
`void`	`testCustomByPositionWrappedPrimitiveDataTypeMismatch()` Tests mapping fields of a wrapped primitive destination object by `CsvCustomBindByPosition` with mismatching types.
`void`	`testCustomConverterRequiredEmptyInput()`
`void`	`testDateAnnotationOnNondateReading()`
`void`	`testDateAnnotationOnNondateWriting()`
`void`	`testExceptionsSuppressed()`
`void`	`testFormatByNameWriteInvalidFormatString()`
`void`	`testFormatByPositionWriteInvalidFormatString()`
`void`	`testGoodDataByName()` Tests mapping of all primitive types by name.
`void`	`testGoodDataByNameUnordered()`
`void`	`testGoodDataByPosition()` Tests mapping fields of all wrapped primitive destination objects by `CsvBindByPosition`.
`void`	`testGoodDataByPositionUnordered()`
`void`	`testGoodDataCustomByName()` Tests mapping fields of all wrapped primitive destination objects by `CsvCustomBindByName`.
`void`	`testGoodDataCustomByPosition()` Tests mapping fields of all wrapped primitive destination objects by `CsvCustomBindByPosition`.
`void`	`testGoodDerivedDataByName()` Tests mapping a subclass with annotations in both subclass and superclass using `CsvBindByName`.
`void`	`testGoodDerivedDataByPositionTypeWithBuilder()` Tests mapping a subclass with annotations in both subclass and superclass using `CsvBindByPosition`.
`void`	`testGoodDerivedDataByPositionTypeWithSet()` Tests mapping a subclass with annotations in both subclass and superclass using `CsvBindByPosition`.
`void`	`testIllegalCurrency()`
`void`	`testIllegalEnumValue()`
`void`	`testMapByNameComplexTypeWrongType()`
`void`	`testMapByNameMismatchingType()`
`void`	`testMapByNameUnbindableField()`
`void`	`testMapByPositionComplexTypeWrongType()`
`void`	`testMapByPositionMismatchingType()`
`void`	`testMapByPositionUnbindableField()`
`void`	`testMapRequiredByNameMissingData()` Tests mapping a required field with `CsvBindByName` when the source data are missing.
`void`	`testMapRequiredByPositionMissingData()`
`void`	`testMultipleExceptionsPerLine()`
`void`	`testOptionalDateUnparseableInput()`
`void`	`testPrematureEOLUsingHeaderNameMapping()`
`void`	`testRequiredColumnNonexistentColumnPositionMapping()`
`void`	`testRequiredColumnNonexistentHeaderNameMapping()`
`void`	`testRequiredDateEmptyInput()`
`void`	`testSetterThrowsException()`
`void`	`testUnparseableLocaleInspecificDate()`
`void`	`testUnparseableLocaleSpecificDate()`
`void`	`testWriteFormatWithColumnPositions()`
`void`	`testWriteFormatWithHeaderNames()`
`void`	`testWrongNumberOfColumnsAllowedByName()` Checks that columns are padded or lopped off if checking is turned off.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AnnotationTest
```
public AnnotationTest()
```
- Method Detail
  - storeSystemLocale
```
@BeforeAll
public static void storeSystemLocale()
```
  - setSystemLocaleToValueNotGerman
```
@BeforeEach
public void setSystemLocaleToValueNotGerman()
```
  - setSystemLocaleBackToDefault
```
@AfterEach
public void setSystemLocaleBackToDefault()
```
  - testGoodDataByName
```
@Test
public void testGoodDataByName()
                              throws FileNotFoundException
```
    Tests mapping of all primitive types by name.
    Also incidentally tests:
    - Mapping of all wrapped primitive types by name
    - Mapping field of destination class with CsvBindByName with members of same names as columns
    - Mapping field of destination class with CsvBindByName with members of different names than columns
    - Unmapped field using header name strategy
    - Mapping required fields by CsvBindByName with complete source data
    - Mapping optional fields by CsvBindByName with complete source data
    - Mapping optional primitive fields by CsvBindByName with missing source data
    - Mapping optional object fields by CsvBindByName with missing source data
    - Mapping to primitive types with private access and no setter method with CsvBindByName
    - Mapping to primitive types with private access and a public setter method with CsvBindByName
    - Mapping to primitive types with private access and a private setter method with CsvBindByName
    - Mapping all locale-specific fields using a different locale
    - Mapping BigDecimal and BigInteger without a locale
    - Mapping all the date types using the default format string and no locale
    - Mapping all the date types using the default format string and a locale
    - Mapping a date type using a specified format string and no locale
    - Mapping a date type using a specified format string and a locale
    - Using a non-existent locale
    - Mapping a time before noon
    - Mapping a time after noon
    - Annotating a column with CsvBindByName with a column name that is not in the input
    - Mapping optional date field using CsvDate and no source data
    - Capture with a matching regular expression
    - Capture without a matching regular expression
    Throws:
    
    FileNotFoundException - Never
  - testAnonymousHeaders
```
@Test
public void testAnonymousHeaders()
                                throws FileNotFoundException
```
    "Anonymous headers" is a term someone came up with for empty headers. If empty fields are converted to null, these null headers can't break opencsv. They are not supported, but they can't cause a crash.
    
    Throws:
    
    FileNotFoundException - Never
  - testCaptureWithNullField
```
@Test
public void testCaptureWithNullField()
                                    throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testGoodDerivedDataByName
```
@Test
public void testGoodDerivedDataByName()
                                     throws IOException
```
    Tests mapping a subclass with annotations in both subclass and superclass using CsvBindByName.
    
    Throws:
    
    IOException - Never
  - testGoodDataByPosition
```
@Test
public void testGoodDataByPosition()
                                  throws FileNotFoundException
```
    Tests mapping fields of all wrapped primitive destination objects by CsvBindByPosition.
    Also incidentally tests:
    - Unmapped field using column number strategy
    - Mapping all wrappers of primitive objects by CsvBindByPosition
    - Mapping required fields by CsvBindByPosition with complete source data
    - Mapping optional fields by CsvBindByPosition with complete source data
    - Mapping optional primitive fields by CsvBindByPosition with missing source data
    - Mapping optional object fields by CsvBindByPosition with missing source data
    - Mapping to primitive types with private access and no setter method with CsvBindByPosition
    - Mapping to primitive types with private access and a public setter method with CsvBindByPosition
    - Mapping to primitive types with private access and a private setter method with CsvBindByPosition
    - Annotating a column with CsvBindByPosition with a column number that is not in the input
    - Capture with a matching regular expression
    - Capture without a matching regular expression
    Throws:
    
    FileNotFoundException - Never
  - testGoodDerivedDataByPositionTypeWithBuilder
```
@Test
public void testGoodDerivedDataByPositionTypeWithBuilder()
                                                        throws IOException
```
    Tests mapping a subclass with annotations in both subclass and superclass using CsvBindByPosition. Type is set by the builder
    
    Throws:
    
    IOException - Never
  - testGoodDerivedDataByPositionTypeWithSet
```
@Test
public void testGoodDerivedDataByPositionTypeWithSet()
                                                    throws IOException
```
    Tests mapping a subclass with annotations in both subclass and superclass using CsvBindByPosition.
    Type set with setType.
    
    Throws:
    
    IOException - Never
  - testGoodDataByNameUnordered
```
@Test
public void testGoodDataByNameUnordered()
                                       throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testGoodDataByPositionUnordered
```
@Test
public void testGoodDataByPositionUnordered()
                                           throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testGoodDataCustomByName
```
@Test
public void testGoodDataCustomByName()
                                    throws FileNotFoundException
```
    Tests mapping fields of all wrapped primitive destination objects by CsvCustomBindByName.
    Also incidentally tests:
    - Mapping fields of all primitive destination types by CsvCustomBindByName
    - Mapping fields of a complex destination object by CsvCustomBindByName
    - Mapping fields of a complex destination object by CsvCustomBindByName with an assignable derived type
    - Mapping fields annotated with CsvBindByName and CsvCustomBindByName
    - Mapping to complex destination objects with private access and no setter method with CsvCustomBindByName
    - Mapping to complex destination objects with private access and a public setter method with CsvCustomBindByName
    - Mapping to complex destination objects with private access and a private setter method with CsvCustomBindByName
    - Mapping with ConvertGermanToBoolean using all available values
    - Mapping with ConvertGermanToBoolean using an empty input
    - Mapping with ConvertSplitOnWhitespace using multiple whitespace-separated values (space, tab)
    - Mapping with ConvertSplitOnWhitespace using a null input string
    - Mapping with ConvertSplitOnWhitespace using a single string with no whitespace
    - Mapping with ConvertSplitOnWhitespace using an input string of only whitespace characters
    Throws:
    
    FileNotFoundException - Never
  - testGoodDataCustomByPosition
```
@Test
public void testGoodDataCustomByPosition()
                                        throws FileNotFoundException
```
    Tests mapping fields of all wrapped primitive destination objects by CsvCustomBindByPosition.
    Also incidentally tests:
    - Mapping fields of all primitive destination types by CsvCustomBindByPosition
    - Mapping fields of a complex destination object by CsvCustomBindByPosition
    - Mapping fields of a complex destination object by CsvCustomBindByPosition with an assignable derived type
    - Mapping fields annotated with CsvBindByPosition and CsvCustomBindByPosition
    - Mapping to complex destination objects with private access and no setter method with CsvCustomBindByPosition
    - Mapping to complex destination objects with private access and a public setter method with CsvCustomBindByPosition
    - Mapping to complex destination objects with private access and a private setter method with CsvCustomBindByPosition
    Throws:
    
    FileNotFoundException - Never
  - testMapRequiredByNameMissingData
```
@Test
public void testMapRequiredByNameMissingData()
                                            throws FileNotFoundException
```
    Tests mapping a required field with CsvBindByName when the source data are missing.
    Also incidentally tests:
    - Error in input on line x
    Throws:
    
    FileNotFoundException - Never
  - testMapRequiredByPositionMissingData
```
@Test
public void testMapRequiredByPositionMissingData()
                                                throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testMapByNameMismatchingType
```
@Test
public void testMapByNameMismatchingType()
                                        throws IOException
```
    Throws:
    
    IOException
  - testMapByPositionMismatchingType
```
@Test
public void testMapByPositionMismatchingType()
                                            throws IOException
```
    Throws:
    
    IOException
  - testMapByNameUnbindableField
```
@Test
public void testMapByNameUnbindableField()
```
  - testMapByPositionUnbindableField
```
@Test
public void testMapByPositionUnbindableField()
```
  - testBadDataExceptionsCapturedUnordered
```
@Test
public void testBadDataExceptionsCapturedUnordered()
```
  - testMultipleExceptionsPerLine
```
@Test
public void testMultipleExceptionsPerLine()
                                         throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testRequiredDateEmptyInput
```
@Test
public void testRequiredDateEmptyInput()
                                      throws IOException
```
    Throws:
    
    IOException
  - testUnparseableLocaleSpecificDate
```
@Test
public void testUnparseableLocaleSpecificDate()
                                             throws IOException
```
    Throws:
    
    IOException
  - testOptionalDateUnparseableInput
```
@Test
public void testOptionalDateUnparseableInput()
                                            throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testUnparseableLocaleInspecificDate
```
@Test
public void testUnparseableLocaleInspecificDate()
                                               throws IOException
```
    Throws:
    
    IOException
  - testExceptionsSuppressed
```
@Test
public void testExceptionsSuppressed()
```
  - testDateAnnotationOnNondateReading
```
@Test
public void testDateAnnotationOnNondateReading()
```
  - testDateAnnotationOnNondateWriting
```
@Test
public void testDateAnnotationOnNondateWriting()
                                              throws com.opencsv.exceptions.CsvException
```
    Throws:
    
    com.opencsv.exceptions.CsvException
  - testMapByNameComplexTypeWrongType
```
@Test
public void testMapByNameComplexTypeWrongType()
                                             throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testMapByPositionComplexTypeWrongType
```
@Test
public void testMapByPositionComplexTypeWrongType()
                                                 throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testCustomByPositionWrappedPrimitiveDataTypeMismatch
```
@Test
public void testCustomByPositionWrappedPrimitiveDataTypeMismatch()
                                                                throws FileNotFoundException
```
    Tests mapping fields of a wrapped primitive destination object by CsvCustomBindByPosition with mismatching types.
    
    Throws:
    
    FileNotFoundException - Never
  - testCustomByNameWrappedPrimitiveDataTypeMismatch
```
@Test
public void testCustomByNameWrappedPrimitiveDataTypeMismatch()
                                                            throws FileNotFoundException
```
    Tests mapping fields of a wrapped primitive destination object by CsvCustomBindByName with mismatching types.
    Also incidentally tests:
    - Mapping with ConvertGermanToBoolean using an invalid string
    Throws:
    
    FileNotFoundException - Never
  - testBadConverter
```
@Test
public void testBadConverter()
```
  - testRequiredColumnNonexistentHeaderNameMapping
```
@Test
public void testRequiredColumnNonexistentHeaderNameMapping()
                                                          throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testRequiredColumnNonexistentColumnPositionMapping
```
@Test
public void testRequiredColumnNonexistentColumnPositionMapping()
                                                              throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testPrematureEOLUsingHeaderNameMapping
```
@Test
public void testPrematureEOLUsingHeaderNameMapping()
                                                  throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testCustomConverterRequiredEmptyInput
```
@Test
public void testCustomConverterRequiredEmptyInput()
                                                 throws FileNotFoundException
```
    Throws:
    
    FileNotFoundException
  - testSetterThrowsException
```
@Test
public void testSetterThrowsException()
```
  - testCaptureByNameInvalidRegex
```
@Test
public void testCaptureByNameInvalidRegex()
```
  - testCaptureByPositionInvalidRegex
```
@Test
public void testCaptureByPositionInvalidRegex()
```
  - testCaptureByNameRegexWithoutCaptureGroup
```
@Test
public void testCaptureByNameRegexWithoutCaptureGroup()
```
  - testCaptureByPositionRegexWithoutCaptureGroup
```
@Test
public void testCaptureByPositionRegexWithoutCaptureGroup()
```
  - testFormatByNameWriteInvalidFormatString
```
@Test
public void testFormatByNameWriteInvalidFormatString()
```
  - testFormatByPositionWriteInvalidFormatString
```
@Test
public void testFormatByPositionWriteInvalidFormatString()
```
  - testWriteFormatWithHeaderNames
```
@Test
public void testWriteFormatWithHeaderNames()
                                          throws com.opencsv.exceptions.CsvException
```
    Throws:
    
    com.opencsv.exceptions.CsvException
  - testWriteFormatWithColumnPositions
```
@Test
public void testWriteFormatWithColumnPositions()
                                              throws com.opencsv.exceptions.CsvException
```
    Throws:
    
    com.opencsv.exceptions.CsvException
  - testIllegalEnumValue
```
@Test
public void testIllegalEnumValue()
                                throws IOException
```
    Throws:
    
    IOException
  - testIllegalCurrency
```
@Test
public void testIllegalCurrency()
                               throws IOException
```
    Throws:
    
    IOException
  - testWrongNumberOfColumnsAllowedByName
```
@Test
public void testWrongNumberOfColumnsAllowedByName()
                                                 throws FileNotFoundException
```
    Checks that columns are padded or lopped off if checking is turned off.
    
    Throws:
    
    FileNotFoundException - Never

Class AnnotationTest

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AnnotationTest

Method Detail

storeSystemLocale

setSystemLocaleToValueNotGerman

setSystemLocaleBackToDefault

testGoodDataByName

testAnonymousHeaders

testCaptureWithNullField

testGoodDerivedDataByName

testGoodDataByPosition

testGoodDerivedDataByPositionTypeWithBuilder

testGoodDerivedDataByPositionTypeWithSet

testGoodDataByNameUnordered

testGoodDataByPositionUnordered

testGoodDataCustomByName

testGoodDataCustomByPosition

testMapRequiredByNameMissingData

testMapRequiredByPositionMissingData

testMapByNameMismatchingType

testMapByPositionMismatchingType

testMapByNameUnbindableField

testMapByPositionUnbindableField

testBadDataExceptionsCapturedUnordered

testMultipleExceptionsPerLine

testRequiredDateEmptyInput

testUnparseableLocaleSpecificDate

testOptionalDateUnparseableInput

testUnparseableLocaleInspecificDate

testExceptionsSuppressed

testDateAnnotationOnNondateReading

testDateAnnotationOnNondateWriting

testMapByNameComplexTypeWrongType

testMapByPositionComplexTypeWrongType

testCustomByPositionWrappedPrimitiveDataTypeMismatch

testCustomByNameWrappedPrimitiveDataTypeMismatch

testBadConverter

testRequiredColumnNonexistentHeaderNameMapping

testRequiredColumnNonexistentColumnPositionMapping

testPrematureEOLUsingHeaderNameMapping

testCustomConverterRequiredEmptyInput

testSetterThrowsException

testCaptureByNameInvalidRegex

testCaptureByPositionInvalidRegex

testCaptureByNameRegexWithoutCaptureGroup

testCaptureByPositionRegexWithoutCaptureGroup

testFormatByNameWriteInvalidFormatString

testFormatByPositionWriteInvalidFormatString

testWriteFormatWithHeaderNames

testWriteFormatWithColumnPositions

testIllegalEnumValue

testIllegalCurrency

testWrongNumberOfColumnsAllowedByName