add fsTick() to RepositoryTestCase

[jgit.git] / org.eclipse.jgit.test / tst / org / eclipse / jgit / lib / RepositoryTestCase.java

/*
 * Copyright (C) 2009, Google Inc.
 * Copyright (C) 2007-2008, Robin Rosenberg <robin.rosenberg@dewire.com>
 * Copyright (C) 2006-2007, Shawn O. Pearce <spearce@spearce.org>
 * Copyright (C) 2009, Yann Simon <yann.simon.fr@gmail.com>
 * and other copyright owners as documented in the project's IP log.
 *
 * This program and the accompanying materials are made available
 * under the terms of the Eclipse Distribution License v1.0 which
 * accompanies this distribution, is reproduced below, and is
 * available at http://www.eclipse.org/org/documents/edl-v10.php
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following
 *   disclaimer in the documentation and/or other materials provided
 *   with the distribution.
 *
 * - Neither the name of the Eclipse Foundation, Inc. nor the
 *   names of its contributors may be used to endorse or promote
 *   products derived from this software without specific prior
 *   written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.eclipse.jgit.lib;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.Map;
import java.util.TreeSet;

import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheIterator;
import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
import org.eclipse.jgit.storage.file.FileRepository;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;

/**
 * Base class for most JGit unit tests.
 *
 * Sets up a predefined test repository and has support for creating additional
 * repositories and destroying them when the tests are finished.
 */
public abstract class RepositoryTestCase extends LocalDiskRepositoryTestCase {
        protected static void copyFile(final File src, final File dst)
                        throws IOException {
                final FileInputStream fis = new FileInputStream(src);
                try {
                        final FileOutputStream fos = new FileOutputStream(dst);
                        try {
                                final byte[] buf = new byte[4096];
                                int r;
                                while ((r = fis.read(buf)) > 0) {
                                        fos.write(buf, 0, r);
                                }
                        } finally {
                                fos.close();
                        }
                } finally {
                        fis.close();
                }
        }

        protected File writeTrashFile(final String name, final String data)
                        throws IOException {
                File path = new File(db.getWorkTree(), name);
                write(path, data);
                return path;
        }

        protected static void checkFile(File f, final String checkData)
                        throws IOException {
                Reader r = new InputStreamReader(new FileInputStream(f), "ISO-8859-1");
                try {
                        char[] data = new char[(int) f.length()];
                        if (f.length() !=  r.read(data))
                                throw new IOException("Internal error reading file data from "+f);
                        assertEquals(checkData, new String(data));
                } finally {
                        r.close();
                }
        }

        /** Test repository, initialized for this test case. */
        protected FileRepository db;

        /** Working directory of {@link #db}. */
        protected File trash;

        @Override
        protected void setUp() throws Exception {
                super.setUp();
                db = createWorkRepository();
                trash = db.getWorkTree();
        }

        public static final int MOD_TIME = 1;

        public static final int SMUDGE = 2;

        public static final int LENGTH = 4;

        public static final int CONTENT_ID = 8;

        /**
         * Represent the state of the index in one String. This representation is
         * useful when writing tests which do assertions on the state of the index.
         * By default information about path, mode, stage (if different from 0) is
         * included. A bitmask controls which additional info about
         * modificationTimes, smudge state and length is included.
         * <p>
         * The format of the returned string is described with this BNF:
         *
         * <pre>
         * result = ( "[" path mode stage? time? smudge? length? sha1? "]" )* .
         * mode = ", mode:" number .
         * stage = ", stage:" number .
         * time = ", time:t" timestamp-index .
         * smudge = "" | ", smudged" .
         * length = ", length:" number .
         * sha1 = ", sha1:" hex-sha1 .
         *
         * 'stage' is only presented when the stage is different from 0. All
         * reported time stamps are mapped to strings like "t0", "t1", ... "tn". The
         * smallest reported time-stamp will be called "t0". This allows to write
         * assertions against the string although the concrete value of the
         * time stamps is unknown.
         *
         * @param includedOptions
         *            a bitmask constructed out of the constants {@link #MOD_TIME},
         *            {@link #SMUDGE}, {@link #LENGTH} and {@link #CONTENT_ID}
         *            controlling which info is present in the resulting string.
         * @return a string encoding the index state
         * @throws IllegalStateException
         * @throws IOException
         */
        public String indexState(int includedOptions)
                        throws IllegalStateException, IOException {
                DirCache dc = db.readDirCache();
                StringBuilder sb = new StringBuilder();
                TreeSet<Long> timeStamps = null;

                // iterate once over the dircache just to collect all time stamps
                if (0 != (includedOptions & MOD_TIME)) {
                        timeStamps = new TreeSet<Long>();
                        for (int i=0; i<dc.getEntryCount(); ++i)
                                timeStamps.add(Long.valueOf(dc.getEntry(i).getLastModified()));
                }

                // iterate again, now produce the result string
                NameConflictTreeWalk tw = new NameConflictTreeWalk(db);
                tw.reset();
                tw.addTree(new DirCacheIterator(dc));
                while (tw.next()) {
                        DirCacheIterator dcIt = tw.getTree(0, DirCacheIterator.class);
                        sb.append("["+tw.getPathString()+", mode:" + dcIt.getEntryFileMode());
                        int stage = dcIt.getDirCacheEntry().getStage();
                        if (stage != 0)
                                sb.append(", stage:" + stage);
                        if (0 != (includedOptions & MOD_TIME)) {
                                sb.append(", time:t"+
                                        timeStamps.headSet(Long.valueOf(dcIt.getDirCacheEntry().getLastModified())).size());
                        }
                        if (0 != (includedOptions & SMUDGE))
                                if (dcIt.getDirCacheEntry().isSmudged())
                                        sb.append(", smudged");
                        if (0 != (includedOptions & LENGTH))
                                sb.append(", length:"
                                                + Integer.toString(dcIt.getDirCacheEntry().getLength()));
                        if (0 != (includedOptions & CONTENT_ID))
                                sb.append(", sha1:" + ObjectId.toString(dcIt
                                                                .getEntryObjectId()));
                        sb.append("]");
                }
                return sb.toString();
        }

        /**
         * Helper method to map arbitrary objects to user-defined names. This can be
         * used create short names for objects to produce small and stable debug
         * output. It is guaranteed that when you lookup the same object multiple
         * times even with different nameTemplates this method will always return
         * the same name which was derived from the first nameTemplate.
         * nameTemplates can contain "%n" which will be replaced by a running number
         * before used as a name.
         *
         * @param l
         *            the object to lookup
         * @param nameTemplate
         *            the name for that object. Can contain "%n" which will be
         *            replaced by a running number before used as a name. If the
         *            lookup table already contains the object this parameter will
         *            be ignored
         * @param lookupTable
         *            a table storing object-name mappings.
         * @return a name of that object. Is not guaranteed to be unique. Use
         *         nameTemplates containing "%n" to always have unique names
         */
        public static String lookup(Object l, String nameTemplate,
                        Map<Object, String> lookupTable) {
                String name = lookupTable.get(l);
                if (name == null) {
                        name = nameTemplate.replaceAll("%n",
                                        Integer.toString(lookupTable.size()));
                        lookupTable.put(l, name);
                }
                return name;
        }

        /**
         * Waits until it is guaranteed that a subsequent file modification has a
         * younger modification timestamp than the modification timestamp of the
         * given file. This is done by touching a temporary file, reading the
         * lastmodified attribute and, if needed, sleeping. After sleeping this loop
         * starts again until the filesystem timer has advanced enough.
         *
         * @param lastFile
         *            the file on which we want to wait until the filesystem timer
         *            has advanced more than the lastmodification timestamp of this
         *            file
         * @return return the last measured value of the filesystem timer which is
         *         greater than then the lastmodification time of lastfile.
         * @throws InterruptedException
         * @throws IOException
         */
        public static long fsTick(File lastFile) throws InterruptedException,
                        IOException {
                long sleepTime = 1;
                File tmp = File.createTempFile("FileTreeIteratorWithTimeControl", null);
                try {
                        long startTime = (lastFile == null) ? tmp.lastModified() : lastFile
                                        .lastModified();
                        long actTime = tmp.lastModified();
                        while (actTime <= startTime) {
                                Thread.sleep(sleepTime);
                                sleepTime *= 5;
                                tmp.setLastModified(System.currentTimeMillis());
                                actTime = tmp.lastModified();
                        }
                        return actTime;
                } finally {
                        tmp.delete();
                }
        }
}