コード例 #1
0
        public virtual void TestGetFilterLocalFsSetsConfs()
        {
            FilterFileSystem flfs = (FilterFileSystem)FileSystem.Get(URI.Create("flfs:/"), conf
                                                                     );

            CheckFsConf(flfs, conf, 3);
        }
コード例 #2
0
        public virtual void TestWriteChecksumPassthru()
        {
            FileSystem mockFs = Org.Mockito.Mockito.Mock <FileSystem>();
            FileSystem fs     = new FilterFileSystem(mockFs);

            fs.SetWriteChecksum(false);
            Org.Mockito.Mockito.Verify(mockFs).SetWriteChecksum(Matchers.Eq(false));
            Org.Mockito.Mockito.Reset(mockFs);
            fs.SetWriteChecksum(true);
            Org.Mockito.Mockito.Verify(mockFs).SetWriteChecksum(Matchers.Eq(true));
        }
コード例 #3
0
        public virtual void TestDelete()
        {
            FileSystem mockFs = Org.Mockito.Mockito.Mock <FileSystem>();
            FileSystem fs     = new FilterFileSystem(mockFs);
            Path       path   = new Path("/a");

            fs.Delete(path, false);
            Org.Mockito.Mockito.Verify(mockFs).Delete(Eq(path), Eq(false));
            Org.Mockito.Mockito.Reset(mockFs);
            fs.Delete(path, true);
            Org.Mockito.Mockito.Verify(mockFs).Delete(Eq(path), Eq(true));
        }
コード例 #4
0
        public virtual void TestInitFilterFsSetsEmbedConf()
        {
            LocalFileSystem lfs = new LocalFileSystem();

            CheckFsConf(lfs, null, 2);
            FilterFileSystem ffs = new FilterFileSystem(lfs);

            Assert.Equal(lfs, ffs.GetRawFileSystem());
            CheckFsConf(ffs, null, 3);
            ffs.Initialize(URI.Create("filter:/"), conf);
            CheckFsConf(ffs, conf, 3);
        }
コード例 #5
0
        public virtual void TestDeleteOnExitFNF()
        {
            FileSystem mockFs = Org.Mockito.Mockito.Mock <FileSystem>();
            FileSystem fs     = new FilterFileSystem(mockFs);
            Path       path   = new Path("/a");

            // don't delete on close if path doesn't exist
            NUnit.Framework.Assert.IsFalse(fs.DeleteOnExit(path));
            Org.Mockito.Mockito.Verify(mockFs).GetFileStatus(Eq(path));
            Org.Mockito.Mockito.Reset(mockFs);
            fs.Close();
            Org.Mockito.Mockito.Verify(mockFs, Org.Mockito.Mockito.Never()).GetFileStatus(Eq(
                                                                                              path));
            Org.Mockito.Mockito.Verify(mockFs, Org.Mockito.Mockito.Never()).Delete(Any <Path>(
                                                                                       ), AnyBoolean());
        }
コード例 #6
0
        public virtual void TestDeleteOnExitRemoved()
        {
            FileSystem mockFs = Org.Mockito.Mockito.Mock <FileSystem>();
            FileSystem fs     = new FilterFileSystem(mockFs);
            Path       path   = new Path("/a");

            // don't delete on close if path existed, but later removed
            Org.Mockito.Mockito.When(mockFs.GetFileStatus(Eq(path))).ThenReturn(new FileStatus
                                                                                    ());
            Assert.True(fs.DeleteOnExit(path));
            Org.Mockito.Mockito.Verify(mockFs).GetFileStatus(Eq(path));
            Org.Mockito.Mockito.Reset(mockFs);
            fs.Close();
            Org.Mockito.Mockito.Verify(mockFs).GetFileStatus(Eq(path));
            Org.Mockito.Mockito.Verify(mockFs, Org.Mockito.Mockito.Never()).Delete(Any <Path>(
                                                                                       ), AnyBoolean());
        }
コード例 #7
0
        public virtual void TestDeleteOnExit()
        {
            FileSystem mockFs = Org.Mockito.Mockito.Mock <FileSystem>();
            FileSystem fs     = new FilterFileSystem(mockFs);
            Path       path   = new Path("/a");

            // delete on close if path does exist
            Org.Mockito.Mockito.When(mockFs.GetFileStatus(Eq(path))).ThenReturn(new FileStatus
                                                                                    ());
            Assert.True(fs.DeleteOnExit(path));
            Org.Mockito.Mockito.Verify(mockFs).GetFileStatus(Eq(path));
            Org.Mockito.Mockito.Reset(mockFs);
            Org.Mockito.Mockito.When(mockFs.GetFileStatus(Eq(path))).ThenReturn(new FileStatus
                                                                                    ());
            fs.Close();
            Org.Mockito.Mockito.Verify(mockFs).GetFileStatus(Eq(path));
            Org.Mockito.Mockito.Verify(mockFs).Delete(Eq(path), Eq(true));
        }
コード例 #8
0
        /// <exception cref="System.Exception"/>
        private void CheckInit(FilterFileSystem fs, bool expectInit)
        {
            URI uri = URI.Create("filter:/");

            fs.Initialize(uri, conf);
            FileSystem embedFs = fs.GetRawFileSystem();

            if (expectInit)
            {
                Org.Mockito.Mockito.Verify(embedFs, Org.Mockito.Mockito.Times(1)).Initialize(Matchers.Eq
                                                                                                 (uri), Matchers.Eq(conf));
            }
            else
            {
                Org.Mockito.Mockito.Verify(embedFs, Org.Mockito.Mockito.Times(0)).Initialize(Matchers.Any
                                                                                             <URI>(), Matchers.Any <Configuration>());
            }
        }
コード例 #9
0
        public virtual void TestCancelDeleteOnExit()
        {
            FileSystem mockFs = Org.Mockito.Mockito.Mock <FileSystem>();
            FileSystem fs     = new FilterFileSystem(mockFs);
            Path       path   = new Path("/a");

            // don't delete on close if path existed, but later cancelled
            Org.Mockito.Mockito.When(mockFs.GetFileStatus(Eq(path))).ThenReturn(new FileStatus
                                                                                    ());
            Assert.True(fs.DeleteOnExit(path));
            Org.Mockito.Mockito.Verify(mockFs).GetFileStatus(Eq(path));
            Assert.True(fs.CancelDeleteOnExit(path));
            NUnit.Framework.Assert.IsFalse(fs.CancelDeleteOnExit(path));
            // false because not registered
            Org.Mockito.Mockito.Reset(mockFs);
            fs.Close();
            Org.Mockito.Mockito.Verify(mockFs, Org.Mockito.Mockito.Never()).GetFileStatus(Any
                                                                                          <Path>());
            Org.Mockito.Mockito.Verify(mockFs, Org.Mockito.Mockito.Never()).Delete(Any <Path>(
                                                                                       ), AnyBoolean());
        }