//LUCENENET TODO: Incompatibility issues because this was ported from Lucene 8.2.0, and we are 4.8.0

//Lucene version compatibility level 8.2.0
//using Lucene.Net.Analysis;
//using Lucene.Net.Documents;
//using Lucene.Net.Index;
//using Lucene.Net.Store;
//using Lucene.Net.Support;
//using System;
//using System.Collections.Generic;

//using System.Text;

//namespace Lucene.Net.Codecs.Compressing
//{
//    /*
//    * 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.
//    */

//#if TESTFRAMEWORK_MSTEST
//    [Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute]
//#endif
//    public class TestCompressingStoredFieldsFormat : BaseStoredFieldsFormatTestCase
//    {
//        const long SECOND = 1000L;
//        const long HOUR = 60 * 60 * SECOND;
//        const long DAY = 24 * HOUR;

//        protected override Codec GetCodec()
//        {
//            return CompressingCodec.RandomInstance(Random);
//        }

//        //        public void testDeletePartiallyWrittenFilesIfAbort() 
//        //        {
//        //            Directory dir = NewDirectory();
//        //    IndexWriterConfig iwConf = NewIndexWriterConfig(new MockAnalyzer(Random));
//        //        iwConf.SetMaxBufferedDocs(Random.Next(2, 30 + 1));
//        //    iwConf.SetCodec(CompressingCodec.RandomInstance(Random));
//        //    // disable CFS because this test checks file names
//        //    iwConf.SetMergePolicy(NewLogMergePolicy(false));
//        //    iwConf.SetUseCompoundFile(false);

//        //    // Cannot use RIW because this test wants CFS to stay off:
//        //    IndexWriter iw = new IndexWriter(dir, iwConf);

//        //        Document validDoc = new Document();
//        //        validDoc.Add(new IntPoint("id", 0));
//        //    validDoc.Add(new StoredField("id", 0));
//        //    iw.AddDocument(validDoc);
//        //    iw.Commit();

//        //    // make sure that #writeField will fail to trigger an abort
//        //    Document invalidDoc = new Document();
//        //        FieldType fieldType = new FieldType();
//        //        fieldType.IsStored=(true);
//        //            invalidDoc.Add(new Field("invalid", fieldType)
//        //        {

//        //            @Override
//        //      public String stringValue()
//        //            {
//        //                // TODO: really bad & scary that this causes IW to
//        //                // abort the segment!!  We should fix this.
//        //                return null;
//        //            }

//        //        });

//        //    try {
//        //      iw.AddDocument(invalidDoc);
//        //      iw.Commit();
//        //    } catch(ArgumentException iae) {
//        //      // expected
//        //      assertEquals(iae, iw.GetTragicException());
//        //}
//        // Writer should be closed by tragedy
//        //assertFalse(iw.isOpen());
//        //dir.Dispose();
//        //  }

//        public void testZFloat()
//        {
//            byte[] buffer = new byte[5]; // we never need more than 5 bytes
//            ByteArrayDataOutput @out = new ByteArrayDataOutput(buffer);
//            ByteArrayDataInput @in = new ByteArrayDataInput(buffer);

//            // round-trip small integer values
//            for (int i = short.MinValue; i < short.MaxValue; i++)
//            {
//                float f = (float)i;
//                CompressingStoredFieldsWriter.writeZFloat(@out, f);
//                @in.Reset(buffer, 0, @out.Position);
//                float g = CompressingStoredFieldsReader.readZFloat(@in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.SingleToInt32Bits(f), J2N.BitConversion.SingleToInt32Bits(g));

//                // check that compression actually works
//                if (i >= -1 && i <= 123)
//                {
//                    assertEquals(1, @out.Position); // single byte compression
//                }
//                @out.Reset(buffer);
//            }

//            // round-trip special values
//            float[] special = {
//        -0.0f,
//        +0.0f,
//        float.NegativeInfinity,
//        float.PositiveInfinity,
//        float.MinValue,
//        float.MaxValue,
//        float.NaN,
//    };

//            foreach (float f in special)
//            {
//                CompressingStoredFieldsWriter.writeZFloat(out, f);
//                @in.Reset(buffer, 0, @out.Position);
//                float g = CompressingStoredFieldsReader.readZFloat(in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.SingleToInt32Bits(f), J2N.BitConversion.SingleToInt32Bits(g));
//                @out.Reset(buffer);
//            }

//            // round-trip random values
//            Random r = Random;
//            for (int i = 0; i < 100000; i++)
//            {
//                float f = r.nextFloat() * (Random.nextInt(100) - 50);
//                CompressingStoredFieldsWriter.writeZFloat(@out, f);
//                assertTrue("length=" + @out.Position + ", f=" + f, @out.Position <= ((J2N.BitConversion.SingleToInt32Bits(f) >>> 31) == 1 ? 5 : 4));
//                @in.Reset(buffer, 0, @out.Position);
//                float g = CompressingStoredFieldsReader.readZFloat(@in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.SingleToInt32Bits(f), J2N.BitConversion.SingleToInt32Bits(g));
//                @out.Reset(buffer);
//            }
//        }

//        public void testZDouble()
//        {
//            byte[] buffer = new byte[9]; // we never need more than 9 bytes
//            ByteArrayDataOutput @out = new ByteArrayDataOutput(buffer);
//            ByteArrayDataInput @in = new ByteArrayDataInput(buffer);

//            // round-trip small integer values
//            for (int i = short.MinValue; i < short.MaxValue; i++)
//            {
//                double x = (double)i;
//                CompressingStoredFieldsWriter.WriteZDouble(@out, x);
//                @in.Reset(buffer, 0, @out.Position);
//                double y = CompressingStoredFieldsReader.ReadZDouble(@in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.DoubleToInt64Bits(x), J2N.BitConversion.DoubleToInt64Bits(y));

//                // check that compression actually works
//                if (i >= -1 && i <= 124)
//                {
//                    assertEquals(1, @out.Position); // single byte compression
//                }
//                @out.Reset(buffer);
//            }

//            // round-trip special values
//            double[] special = {
//        -0.0d,
//        +0.0d,
//        Double.NegativeInfinity,
//        Double.PositiveInfinity,
//        Double.MinValue,
//        Double.MaxValue,
//        Double.NaN
//    };

//            foreach (double x in special)
//            {
//                CompressingStoredFieldsWriter.writeZDouble(@out, x);
//                @in.Reset(buffer, 0, @out.Position);
//                double y = CompressingStoredFieldsReader.readZDouble(@in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.DoubleToInt64Bits(x), J2N.BitConversion.DoubleToInt64Bits(y));
//                @out.reset(buffer);
//            }

//            // round-trip random values
//            Random r = Random;
//            for (int i = 0; i < 100000; i++)
//            {
//                double x = r.NextDouble() * (Random.nextInt(100) - 50);
//                CompressingStoredFieldsWriter.writeZDouble(@out, x);
//                assertTrue("length=" + @out.Position + ", d=" + x, @out.Position <= (x < 0 ? 9 : 8));
//                @in.Reset(buffer, 0, @out.Position);
//                double y = CompressingStoredFieldsReader.readZDouble(@in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.DoubleToInt64Bits(x), J2N.BitConversion.DoubleToInt64Bits(y));
//                @out.Reset(buffer);
//            }

//            // same with floats
//            for (int i = 0; i < 100000; i++)
//            {
//                double x = (double)(r.nextFloat() * (Random.nextInt(100) - 50));
//                CompressingStoredFieldsWriter.writeZDouble(out, x);
//                assertTrue("length=" + @out.Position + ", d=" + x, @out.Position <= 5);
//                @in.Reset(buffer, 0, @out.Position);
//                double y = CompressingStoredFieldsReader.readZDouble(@in);
//                assertTrue(@in.Eof);
//                assertEquals(J2N.BitConversion.DoubleToInt64Bits(x), J2N.BitConversion.DoubleToInt64Bits(y));
//                @out.Reset(buffer);
//            }
//        }

//        public void testTLong()
//        {
//            byte[] buffer = new byte[10]; // we never need more than 10 bytes
//            ByteArrayDataOutput @out = new ByteArrayDataOutput(buffer);
//            ByteArrayDataInput @in = new ByteArrayDataInput(buffer);

//            // round-trip small integer values
//            for (int i = short.MinValue; i < short.MaxValue; i++)
//            {
//                foreach (long mul in new long[] { SECOND, HOUR, DAY })
//                {
//                    long l1 = (long)i * mul;
//                    CompressingStoredFieldsWriter.writeTLong(@out, l1);
//                    @in.Reset(buffer, 0, @out.Position);
//                    long l2 = CompressingStoredFieldsReader.readTLong(@in);
//                    assertTrue(@in.Eof);
//                    assertEquals(l1, l2);

//                    // check that compression actually works
//                    if (i >= -16 && i <= 15)
//                    {
//                        assertEquals(1, @out.Position); // single byte compression
//                    }
//                    @out.Reset(buffer);
//                }
//            }

//            // round-trip random values
//            Random r = Random;
//            for (int i = 0; i < 100000; i++)
//            {
//                int numBits = r.nextInt(65);
//                long l1 = r.nextLong() & ((1L << numBits) - 1);
//                switch (r.nextInt(4))
//                {
//                    case 0:
//                        l1 *= SECOND;
//                        break;
//                    case 1:
//                        l1 *= HOUR;
//                        break;
//                    case 2:
//                        l1 *= DAY;
//                        break;
//                    default:
//                        break;
//                }
//                CompressingStoredFieldsWriter.writeTLong(@out, l1);
//                @in.Reset(buffer, 0, @out.Position);
//                long l2 = CompressingStoredFieldsReader.readTLong(@in);
//                assertTrue(@in.Eof);
//                assertEquals(l1, l2);
//                @out.Reset(buffer);
//            }
//        }

//        /**
//         * writes some tiny segments with incomplete compressed blocks,
//         * and ensures merge recompresses them.
//         */
//        public void testChunkCleanup()
//        {
//            Directory dir = NewDirectory();
//            IndexWriterConfig iwConf = NewIndexWriterConfig(new MockAnalyzer(Random));
//            iwConf.SetMergePolicy(NoMergePolicy.INSTANCE);

//            // we have to enforce certain things like maxDocsPerChunk to cause dirty chunks to be created
//            // by this test.
//            iwConf.SetCodec(CompressingCodec.RandomInstance(Random, 4 * 1024, 100, false, 8));
//            IndexWriter iw = new IndexWriter(dir, iwConf);
//            DirectoryReader ir = DirectoryReader.Open(iw);
//            for (int i = 0; i < 5; i++)
//            {
//                Document doc = new Document();
//                doc.Add(new StoredField("text", "not very long at all"));
//                iw.AddDocument(doc);
//                // force flush
//                DirectoryReader ir2 = DirectoryReader.OpenIfChanged(ir);
//                assertNotNull(ir2);
//                ir.Dispose();
//                ir = ir2;
//                // examine dirty counts:
//                foreach (LeafReaderContext leaf in ir2.leaves())
//                {
//                    CodecReader sr = (CodecReader)leaf.reader();
//                    CompressingStoredFieldsReader reader = (CompressingStoredFieldsReader)sr.getFieldsReader();
//                    assertEquals(1, reader.getNumChunks());
//                    assertEquals(1, reader.getNumDirtyChunks());
//                }
//            }
//            iw.Config.SetMergePolicy(NewLogMergePolicy());
//            iw.ForceMerge(1);
//            DirectoryReader ir2 = DirectoryReader.OpenIfChanged(ir);
//            assertNotNull(ir2);
//            ir.close();
//            ir = ir2;
//            CodecReader sr = (CodecReader)getOnlyLeafReader(ir);
//            CompressingStoredFieldsReader reader = (CompressingStoredFieldsReader)sr.getFieldsReader();
//            // we could get lucky, and have zero, but typically one.
//            assertTrue(reader.getNumDirtyChunks() <= 1);
//            ir.Dispose();
//            iw.Dispose();
//            dir.Dispose();
//        }
//    }
//}
