org.tigris.subversion.javahl.tests.WC Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javasvn Show documentation
Show all versions of javasvn Show documentation
The only pure Java Subversion library in the world
package org.tigris.subversion.javahl.tests;
/**
* @copyright
* ====================================================================
* Copyright (c) 2003-2004 CollabNet. All rights reserved.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://subversion.tigris.org/license-1.html.
* If newer versions of this license are posted there, you may use a
* newer version instead, at your option.
*
* This software consists of voluntary contributions made by many
* individuals. For exact contribution history, see the revision
* history and logs, available at http://subversion.tigris.org/.
* ====================================================================
* @endcopyright
*/
import org.tigris.subversion.javahl.Status;
import org.tigris.subversion.javahl.NodeKind;
import org.tigris.subversion.javahl.DirEntry;
import java.io.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import junit.framework.Assert;
/**
* This class describe the expected state of the working copy
*/
public class WC
{
/**
* the map of the items of the working copy. The relative path is the key
* for the map
*/
Map items = new HashMap();
/**
* Generate from the expected state of the working copy a new working copy
* @param root the working copy directory
* @throws IOException
*/
public void materialize(File root) throws IOException
{
// generate all directories first
Iterator it = items.values().iterator();
while (it.hasNext())
{
Item item = (Item) it.next();
if (item.myContent == null) // is a directory
{
File dir = new File(root, item.myPath);
if (!dir.exists())
dir.mkdirs();
}
}
// generate all files with the content in the second run
it = items.values().iterator();
while (it.hasNext())
{
Item item = (Item) it.next();
if (item.myContent != null) // is a file
{
File file = new File(root, item.myPath);
PrintWriter pw = new PrintWriter(new FileOutputStream(file));
pw.print(item.myContent);
pw.close();
}
}
}
/**
* Add a new item to the working copy
* @param path the path of the item
* @param content the content of the item. A null content signifies a
* directory
* @return the new Item object
*/
public Item addItem(String path, String content)
{
return new Item(path, content);
}
/**
* Returns the item at a path
* @param path the path, where the item is searched
* @return the found item
*/
public Item getItem(String path)
{
return (Item) items.get(path);
}
/**
* Remove the item at a path
* @param path the path, where the item is removed
*/
public void removeItem(String path)
{
items.remove(path);
}
/**
* Set text (content) status of the item at a path
* @param path the path, where the status is set
* @param status the new text status
*/
public void setItemTextStatus(String path, int status)
{
((Item) items.get(path)).textStatus = status;
}
/**
* Set property status of the item at a path
* @param path the path, where the status is set
* @param status the new property status
*/
public void setItemPropStatus(String path, int status)
{
((Item) items.get(path)).propStatus = status;
}
/**
* Set the revision number of the item at a path
* @param path the path, where the revision number is set
* @param revision the new revision number
*/
public void setItemWorkingCopyRevision(String path, long revision)
{
((Item) items.get(path)).workingCopyRev = revision;
}
/**
* Returns the file content of the item at a path
* @param path the path, where the content is retrieved
* @return the content of the file
*/
public String getItemContent(String path)
{
return ((Item) items.get(path)).myContent;
}
/**
* Set the file content of the item at a path
* @param path the path, where the content is set
* @param content the new content
*/
public void setItemContent(String path, String content)
{
// since having no content signals a directory, changes of removing the
// content or setting a former not set content is not allowed. That
// would change the type of the item.
Assert.assertNotNull("cannot unset content", content);
Item i = (Item) items.get(path);
Assert.assertNotNull("cannot set content on directory", i.myContent);
i.myContent = content;
}
/**
* set the flag to check the content of item at a path during next check.
* @param path the path, where the flag is set
* @param check the flag
*/
public void setItemCheckContent(String path, boolean check)
{
Item i = (Item) items.get(path);
i.checkContent = check;
}
/**
* Set the expected node kind at a path
* @param path the path, where the node kind is set
* @param nodeKind the expected node kind
*/
public void setItemNodeKind(String path, int nodeKind)
{
Item i = (Item) items.get(path);
i.nodeKind = nodeKind;
}
/**
* Set the expected lock state at a path
* @param path the path, where the lock state is set
* @param isLocked the flag
*/
public void setItemIsLocked(String path, boolean isLocked)
{
Item i = (Item) items.get(path);
i.isLocked = isLocked;
}
/**
* Set the expected switched flag at a path
* @param path the path, where the switch flag is set
* @param isSwitched the flag
*/
public void setItemIsSwitched(String path, boolean isSwitched)
{
Item i = (Item) items.get(path);
i.isSwitched = isSwitched;
}
/**
* Copy an expected working copy state
* @return the copy of the exiting object
*/
public WC copy()
{
WC c = new WC();
Iterator it = items.values().iterator();
while (it.hasNext())
{
((Item) it.next()).copy(c);
}
return c;
}
/**
* Check the result of a single file SVNClient.list call
* @param tested the result array
* @param singleFilePath the path to be checked
* @throws Exception
*/
void check(DirEntry[] tested, String singleFilePath) throws Exception
{
Assert.assertEquals("not a single dir entry", 1, tested.length);
Item item = (Item)items.get(singleFilePath);
Assert.assertNotNull("not found in working copy", item);
Assert.assertNotNull("not a file", item.myContent);
Assert.assertEquals("state says file, working copy not",
tested[0].getNodeKind(),
item.nodeKind == -1 ? NodeKind.file : item.nodeKind);
}
/**
* Check the result of a directory SVNClient.list call
* @param tested the result array
* @param basePath the path of the directory
* @param recursive the recursive flag of the call
* @throws Exception
*/
void check(DirEntry[] tested, String basePath, boolean recursive)
throws Exception
{
// clear the touched flag of all items
Iterator it = items.values().iterator();
while (it.hasNext())
{
Item item = (Item) it.next();
item.touched = false;
}
// normalize directory path
if (basePath != null && basePath.length() > 0)
{
basePath = basePath + "/";
}
else
{
basePath = "";
}
// check all returned DirEntry's
for (int i = 0; i < tested.length; i++)
{
String name = basePath + tested[i].getPath();
Item item = (Item) items.get(name);
Assert.assertNotNull("not found in working copy", item);
if (item.myContent != null)
{
Assert.assertEquals("state says file, working copy not",
tested[i].getNodeKind(),
item.nodeKind == -1 ? NodeKind.file : item.nodeKind);
}
else
{
Assert.assertEquals("state says dir, working copy not",
tested[i].getNodeKind(),
item.nodeKind == -1 ? NodeKind.dir : item.nodeKind);
}
item.touched = true;
}
// all items should have been in items, should had their touched flag
// set
it = items.values().iterator();
while (it.hasNext())
{
Item item = (Item) it.next();
if(!item.touched)
{
if(item.myPath.startsWith(basePath) &&
!item.myPath.equals(basePath))
{
Assert.assertFalse("not found in dir entries", recursive);
boolean found = false;
for(int i = 0; i < tested.length; i++)
{
if(tested[i].getNodeKind() == NodeKind.dir)
{
if(item.myPath.
startsWith(basePath+tested[i].getPath()))
{
found = true;
break;
}
}
}
Assert.assertTrue("not found in dir entries", found);
}
}
}
}
/**
* Check the result of a SVNClient.status versus the expected state
* @param tested the result to be tested
* @param workingCopyPath the path of the working copy
* @throws Exception
*/
void check(Status[] tested, String workingCopyPath) throws Exception
{
// clear the touched flag of all items
Iterator it = items.values().iterator();
while (it.hasNext())
{
Item item = (Item) it.next();
item.touched = false;
}
String normalizeWCPath =
workingCopyPath.replace(File.separatorChar, '/');
// check all result Staus object
for (int i = 0; i < tested.length; i++)
{
String path = tested[i].getPath();
Assert.assertTrue("status path starts not with working copy path",
path.startsWith(normalizeWCPath));
// we calculate the relative path to the working copy root
if (path.length() > workingCopyPath.length() + 1)
{
Assert.assertEquals("missing '/' in status path",
path.charAt(workingCopyPath.length()), '/');
path = path.substring(workingCopyPath.length() + 1);
}
else
// this is the working copy root itself
path = "";
Item item = (Item) items.get(path);
Assert.assertNotNull("status not found in working copy", item);
Assert.assertEquals("wrong text status in working copy",
item.textStatus, tested[i].getTextStatus());
if (item.workingCopyRev != -1)
Assert.assertEquals("wrong revision number in working copy",
item.workingCopyRev, tested[i].getRevisionNumber());
Assert.assertEquals("lock status wrong",
item.isLocked, tested[i].isLocked());
Assert.assertEquals("switch status wrong",
item.isSwitched, tested[i].isSwitched());
Assert.assertEquals("wrong prop status in working copy",
item.propStatus, tested[i].getPropStatus());
if (item.myContent != null)
{
Assert.assertEquals("state says file, working copy not",
tested[i].getNodeKind(),
item.nodeKind == -1 ? NodeKind.file : item.nodeKind);
if (tested[i].getTextStatus() == Status.Kind.normal ||
item.checkContent)
{
File input = new File(workingCopyPath, item.myPath);
Reader rd =
new InputStreamReader(new FileInputStream(input));
StringBuffer buffer = new StringBuffer();
int ch;
while ((ch = rd.read()) != -1)
{
buffer.append((char) ch);
}
rd.close();
Assert.assertEquals("content mismatch", buffer.toString(),
item.myContent);
}
}
else
{
Assert.assertEquals("state says dir, working copy not",
tested[i].getNodeKind(),
item.nodeKind == -1 ? NodeKind.dir : item.nodeKind);
}
item.touched = true;
}
// all items which have the touched flag not set, are missing in the
// result array
it = items.values().iterator();
while (it.hasNext())
{
Item item = (Item) it.next();
Assert.assertTrue("item in working copy not found in status",
item.touched);
}
}
/**
* internal class to discribe a single working copy item
*/
public class Item
{
/**
* the content of a file. A directory has a null content
*/
String myContent;
/**
* the relative path of the item
*/
String myPath;
/**
* the text (content) status of the item
*/
int textStatus = Status.Kind.normal;
/**
* the property status of the item.
*/
int propStatus = Status.Kind.none;
/**
* the expected revision number. -1 means do not check.
*/
long workingCopyRev = -1;
/**
* flag if item has been touched. To detect missing items.
*/
boolean touched;
/**
* flag if the content will be checked
*/
boolean checkContent;
/**
* expected node kind. -1 means do not check.
*/
int nodeKind = -1;
/**
* expected locked status
*/
boolean isLocked;
/**
* expected switched status
*/
boolean isSwitched;
/**
* create a new item
* @param path the path of the item.
* @param content the content of the item. A null signals a directory.
*/
private Item(String path, String content)
{
myPath = path;
myContent = content;
items.put(path, this);
}
/**
* copy constructor
* @param source the copy source.
* @param owner the WC of the copy
*/
private Item(Item source, WC owner)
{
myPath = source.myPath;
myContent = source.myContent;
textStatus = source.textStatus;
propStatus = source.propStatus;
owner.items.put(myPath, this);
}
/**
* copy this item
* @param owner the new WC
* @return the copied item
*/
private Item copy(WC owner)
{
return new Item(this, owner);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy