Test files missing in sdist

Test suite can't be executed from the sdist as some test files seem to be missing from extra-source-files:
Running 1 test suites...
Test suite data-test: RUNNING...
Tests
  write . read == id:                                                                                                                                                                                                                                                                                                                                                                   OK (0.02s)
  write . fast-read == id:                                                                                                                                                                                                                                                                                                                                                              OK
  fromRows . toRows == id:                                                                                                                                                                                                                                                                                                                                                              OK
  fromRight . parseStyleSheet . renderStyleSheet == id:                                                                                                                                                                                                                                                                                                                                 OK
  correct shared strings parsing:                                                                                                                                                                                                                                                                                                                                                       OK
  correct shared strings parsing: single underline:                                                                                                                                                                                                                                                                                                                                     OK
  correct shared strings parsing: double underline:                                                                                                                                                                                                                                                                                                                                     OK
  correct shared strings parsing even when one of the shared strings entry is just <t/>:                                                                                                                                                                                                                                                                                                OK
  correct comments parsing:                                                                                                                                                                                                                                                                                                                                                             OK
  correct custom properties parsing:                                                                                                                                                                                                                                                                                                                                                    OK
  proper results from `formatted`:                                                                                                                                                                                                                                                                                                                                                      OK
  proper results from `formatWorkbook`:                                                                                                                                                                                                                                                                                                                                                 OK
  formatted . toFormattedCells = id:                                                                                                                                                                                                                                                                                                                                                    OK
  proper results from `conditionallyFormatted`:                                                                                                                                                                                                                                                                                                                                         OK
  toXlsxEither: properly formatted:                                                                                                                                                                                                                                                                                                                                                     OK
  toXlsxEither: invalid format:                                                                                                                                                                                                                                                                                                                                                         OK
  toXlsx: correct floats parsing (typed and untyped cells are floats by default):                                                                                                                                                                                                                                                                                                       FAIL
    Exception: data/floats.xlsx: openBinaryFile: does not exist (No such file or directory)
    Use -p '/toXlsx: correct floats parsing (typed and untyped cells are floats by default)/' to rerun this test only.
  toXlsxFast: correct floats parsing (typed and untyped cells are floats by default):                                                                                                                                                                                                                                                                                                   FAIL
    Exception: data/floats.xlsx: openBinaryFile: does not exist (No such file or directory)
    Use -p '/toXlsxFast: correct floats parsing (typed and untyped cells are floats by default)/' to rerun this test only.
  Codec: sheet state visibility
    toXlsxEitherFast
      pure state == toXlsxEitherFast (fromXlsx (defXlsxWithState state)):                                                                                                                                                                                                                                                                                                               OK
        3 tests completed
      should otherwise infer visible state by default:                                                                                                                                                                                                                                                                                                                                  OK
    toXlsxEither
      pure state == toXlsxEither (fromXlsx (defXlsxWithState state)):                                                                                                                                                                                                                                                                                                                   OK
        3 tests completed
      should otherwise infer visible state by default:                                                                                                                                                                                                                                                                                                                                  OK
  Types.Common tests
    date conversions:                                                                                                                                                                                                                                                                                                                                                                   OK
    Converting dates in the vicinity of 1900-03-01 to numbers:                                                                                                                                                                                                                                                                                                                          OK
    dateToNumber . dateFromNumber == id:                                                                                                                                                                                                                                                                                                                                                OK
      22 tests completed
    Types.Common CellRef tests
      textToColumnIndex . columnIndexToText == id:                                                                                                                                                                                                                                                                                                                                      OK
        4 tests completed
      row2coord . coord2row = id:                                                                                                                                                                                                                                                                                                                                                       OK
        6 tests completed
      col2coord . coord2col = id:                                                                                                                                                                                                                                                                                                                                                       OK
        6 tests completed
      fromSingleCellRef' . singleCellRef' = pure:                                                                                                                                                                                                                                                                                                                                       OK
        16 tests completed
      fromRange' . mkRange' = pure:                                                                                                                                                                                                                                                                                                                                                     OK
        16 tests completed
      fromForeignSingleCellRef . mkForeignSingleCellRef = pure:                                                                                                                                                                                                                                                                                                                         OK
        160 tests completed
      fromSingleCellRef' . mkForeignSingleCellRef = pure . snd:                                                                                                                                                                                                                                                                                                                         OK
        160 tests completed
      fromForeignSingleCellRef . singleCellRef' = const empty:                                                                                                                                                                                                                                                                                                                          OK
        16 tests completed
      fromForeignRange . mkForeignRange = pure:                                                                                                                                                                                                                                                                                                                                         OK
        0 tests completed
      fromRange' . mkForeignRange = pure . snd:                                                                                                                                                                                                                                                                                                                                         OK
        0 tests completed
      fromForeignRange . mkRange' = const empty:                                                                                                                                                                                                                                                                                                                                        OK
        16 tests completed
      building single CellRefs:                                                                                                                                                                                                                                                                                                                                                         OK
      parsing single CellRefs as abstract coordinates:                                                                                                                                                                                                                                                                                                                                  OK
      parsing single CellRefs as potentially absolute coordinates:                                                                                                                                                                                                                                                                                                                      OK
      building ranges:                                                                                                                                                                                                                                                                                                                                                                  OK
      parsing ranges CellRefs as abstract coordinates:                                                                                                                                                                                                                                                                                                                                  OK
      parsing ranges CellRefs as potentially absolute coordinates:                                                                                                                                                                                                                                                                                                                      OK
  Types.ConditionalFormatting tests
    fromCursor . toElement == id:                                                                                                                                                                                                                                                                                                                                                       OK (2.60s)
      7776 tests completed
  Pivot table tests
    proper pivot table rendering:                                                                                                                                                                                                                                                                                                                                                       OK
    proper pivot table parsing:                                                                                                                                                                                                                                                                                                                                                         OK
  Drawing tests
    correct drawing parsing:                                                                                                                                                                                                                                                                                                                                                            OK
    write . read == id for Drawings:                                                                                                                                                                                                                                                                                                                                                    OK
    correct chart parsing:                                                                                                                                                                                                                                                                                                                                                              OK
    parse . render == id for line Charts:                                                                                                                                                                                                                                                                                                                                               OK
    parse . render == id for area Charts:                                                                                                                                                                                                                                                                                                                                               OK
    parse . render == id for bar Charts:                                                                                                                                                                                                                                                                                                                                                OK
    parse . render == id for pie Charts:                                                                                                                                                                                                                                                                                                                                                OK
    parse . render == id for scatter Charts:                                                                                                                                                                                                                                                                                                                                            OK
  Types.AutFilter tests
    fromCursor . toElement == id:                                                                                                                                                                                                                                                                                                                                                       OK (0.39s)
      2674 tests completed
  Stream tests
    Writer/shared strings
      Input same as the output:                                                                                                                                                                                                                                                                                                                                                         OK
        206 tests completed
      Set of input texts is same as map length:                                                                                                                                                                                                                                                                                                                                         OK (0.29s)
        2912 tests completed
      Set of input texts is as value set length:                                                                                                                                                                                                                                                                                                                                        OK (0.31s)
        2912 tests completed
    Reader/Writer
      Write as stream, see if memory based implementation can read it:                                                                                                                                                                                                                                                                                                                  OK
      Write as stream, see if memory based implementation can read it:                                                                                                                                                                                                                                                                                                                  OK
      Test a small workbook which has a fullblown sqaure:                                                                                                                                                                                                                                                                                                                               OK
      Test a big workbook as a full square which caused issues with zipstream                  The buffer of zipstream maybe 1kb, this workbook is big enough                  to be more than that.                  So if this encodes/decodes we know we can handle those sizes.                  In some older version the bytestring got cut off resulting in a corrupt xlsx file: OK (0.09s)
    Reader/inline strings
      Can parse row with inline strings:                                                                                                                                                                                                                                                                                                                                                OK
    Reader/floats parsing
      Can parse untyped values as floats:                                                                                                                                                                                                                                                                                                                                               FAIL
        Exception: /build/xlsx-1.1.0/data/floats.xlsx: openBinaryFile: does not exist (No such file or directory)
        Use -p '/Can parse untyped values as floats/' to rerun this test only.

3 out of 63 tests failed (3.77s)
Test suite data-test: FAIL
Test suite logged to: dist/test/xlsx-1.1.0-data-test.log
qrilka / xlsx

Test files missing in sdist #165
