public void WriteTo_Test1()
{
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(_usefilters, indobj);
PDFIndirectObject otherobj = new PDFIndirectObject(this);
PDFStream other = new StreamProxy(_usefilters, otherobj);
string source = "Hello world";
target.WriteLine(source);
target.Flush();
byte[] expected = target.GetStreamData();
target.WriteTo(other);
byte[] actual = other.GetStreamData();
CompareByteArray(expected, actual);
target.Dispose();
other.Dispose();
indobj.Dispose();
otherobj.Dispose();
}
public void PDFStreamConstructor_Test()
{
Stream stream = null;
IStreamFilter[] filters = _usefilters;
PDFIndirectObject indobj = new PDFIndirectObject(this);
bool ownstream = false;
PDFStream target;
try
{
target = new StreamProxy(stream, filters, indobj, ownstream);
Assert.Fail("No Exception thrown for a null stream");
}
catch (ArgumentNullException)
{
TestContext.WriteLine("Sucessfully caught a null reference for the stream");
}
stream = new MemoryStream();
target = new StreamProxy(stream, filters, indobj, ownstream);
Assert.AreEqual(target.IndirectObject, indobj);
Assert.AreEqual(filters, target.Filters);
target.Dispose();
stream.Dispose();
indobj.Dispose();
}
public override void EndObject()
{
PDFIndirectObject obj = this.Stack.Peek().IndirectObject;
this.WriteAnIndirectObject(obj);
base.EndObject();
}
public void Remove_Test()
{
int generation = 1;
PDFXRefTable target = new XRefTableProxy(generation);
int count = target.ReferenceCount;
PDFIndirectObject obj = new PDFIndirectObject(this);
int actual = target.Append(obj);
PDFIndirectObject obj2 = new PDFIndirectObject(this);
actual = target.Append(obj2);
//And check that it is in the list of references
Assert.AreEqual(count + 2, target.ReferenceCount);
Assert.IsTrue(target.Contains(obj2));
//XRef tables should not actualy remove entries, but replace the cell with an empty/deleted reference.
target.Delete(obj2);
Assert.AreEqual(count + 2, target.ReferenceCount);
Assert.IsTrue(target.Contains(obj2));
IIndirectObject removed = target[count + 1].Reference;
Assert.IsNotNull(removed);
Assert.IsTrue(removed.Deleted);
obj.Dispose();
obj2.Dispose();
}
/// <summary>
/// Begns a new data stream on the current indirect object and sets the stream as the new CurrentStream
/// </summary>
/// <param name="onobject"></param>
/// <param name="filters"></param>
public override void BeginStream(PDFObjectRef onobject, IStreamFilter[] filters)
{
PDFIndirectObject pio = onobject.Reference as PDFIndirectObject;
pio.InitStream(filters);
this.Stack.Push(pio.Stream);
}
public void Dispose_Test()
{
IStreamFilter[] filters = _usefilters;
PDFIndirectObject indobj = new PDFIndirectObject(this);
StreamProxy proxy = new StreamProxy(filters, indobj);
PDFStream target = proxy;
target.Dispose();
//As the target owns the inner stream it should be disposed.
Assert.IsNull(proxy.InnerStreamProxy());
MemoryStream ms = new MemoryStream();
bool ownsStream = false;
proxy = new StreamProxy(ms, filters, indobj, ownsStream);
target = proxy;
target.Dispose();
Assert.IsNull(proxy.InnerStreamProxy()); //reference should have gone from the stream
ms.WriteByte(12); //this will fail if the stream has been disposed.
ms.Dispose();
indobj.Dispose();
}
public void GetStreamData_Test()
{
MemoryStream ms = new MemoryStream();
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(ms, _usefilters, indobj, false);
byte[] expected = new byte[] {};
byte[] actual;
actual = target.GetStreamData();
Assert.AreEqual(expected.Length, actual.Length);
expected = new byte[] { 1, 2, 3, 4, 5 };
target.Write(expected);
target.Flush();
actual = target.GetStreamData();
Assert.AreEqual(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
target.Dispose();
ms.Dispose();
indobj.Dispose();
}
protected override void ReleaseIndirectObject(IIndirectObject obj)
{
base.ReleaseIndirectObject(obj);
if (obj is PDFIndirectObject)
{
if (this.TraceLog.ShouldLog(PoolTraceLevel))
{
this.TraceLog.Add(PoolTraceLevel, PoolTraceCategory, "Writing object data for " + obj.ToString() + " and releasing back onto the pool");
}
PDFIndirectObject known = (PDFIndirectObject)obj;
if (known.Written == false)
{
this.WriteAnIndirectObject(known);
}
PDFStream data = known.ObjectData;
PDFStream content = known.HasStream ? known.Stream : null;
if (data != null)
{
this.ReleaseAndRePool(data);
}
if (content != null)
{
this.ReleaseAndRePool(content);
}
known.ReleaseStreams(false);
}
}
public void Dispose_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
Assert.IsNotNull(target.ObjectData);
target.Dispose();
Assert.IsNull(target.ObjectData);
target = new PDFIndirectObject(this);
target.InitStream(null);
Assert.IsNotNull(target.ObjectData);
Assert.IsNotNull(target.Stream);
target.Dispose();
Assert.IsNull(target.ObjectData);
Assert.IsNull(target.Stream);
try
{
target.InitStream(null);
Assert.Fail("Initialized a new stream on a disposed instance");
}
catch (InvalidOperationException)
{
TestContext.WriteLine("Successfully caught the invalid operation for a disposed object");
}
}
public void Type_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
PDFObjectType actual;
actual = target.Type;
Assert.AreEqual(actual, PDFObjectTypes.IndirectObject);
}
public void ObjectData_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
PDFStream actual;
actual = target.ObjectData;
Assert.IsNotNull(actual);
Assert.IsTrue(actual.Type == PDFObjectTypes.Stream);
target.Dispose();
}
/// <summary>
/// Ends the current indirect object and releases
/// </summary>
public override void EndObject()
{
PDFIndirectObject obj = this.Stack.Peek().IndirectObject;
if (this.TraceLog.ShouldLog(TraceLevel.Debug))
{
this.Log(TraceLevel.Debug, "Ended indirect object " + obj.Number + " " + obj.Generation + " R");
}
this.ReleaseIndirectObject(obj);
}
/// <summary>
/// Begins a new indirect object returning a reference to the newly started indirect object
/// </summary>
/// <param name="name">The optional name of the object</param>
/// <returns></returns>
public override PDFObjectRef BeginObject(string name)
{
PDFIndirectObject obj = CreateIndirectObject();
PDFObjectRef oref = this.InitializeIndirectObject(name, obj);
if (this.TraceLog.ShouldLog(TraceLevel.Debug))
{
this.Log(TraceLevel.Debug, "Begun a new indirect object: " + oref + (string.IsNullOrEmpty(name) ? "" : (" with name " + name)));
}
return(oref);
}
public void GetObjectData_Test()
{
using (PDFIndirectObject target = new PDFIndirectObject(this))
{
byte[] expected = new byte[] { };
byte[] actual;
actual = target.GetObjectData();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Length, actual.Length);
}
}
public void InitStream_Test()
{
using (PDFIndirectObject target = new PDFIndirectObject(this))
{
byte[] expected = new byte[] { };
byte[] actual;
Assert.IsNull(target.Stream);
target.InitStream(null);
actual = target.GetStreamData();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Length, actual.Length);
}
}
public void HasStream_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
bool actual;
actual = target.HasStream;
Assert.IsFalse(actual);
target.InitStream(null);
actual = target.HasStream;
Assert.IsTrue(actual);
target.Dispose();
}
public void IndirectObject_Test()
{
MemoryStream ms = new MemoryStream();
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(ms, _usefilters, indobj, false);
PDFIndirectObject actual;
actual = target.IndirectObject;
Assert.AreEqual(actual, indobj);
target.Dispose();
indobj.Dispose();
}
public void Type_Test()
{
IStreamFilter[] filters = _usefilters;
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(filters, indobj);
PDFObjectType actual;
actual = target.Type;
PDFObjectType expected = PDFObjectTypes.Stream;
Assert.AreEqual(expected, actual);
target.Dispose();
indobj.Dispose();
}
public void Write_Test1()
{
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(_usefilters, indobj);
byte[] expected = new byte[] { 1, 2, 3, 4, 5 };
target.Write(expected);
target.Flush();
byte[] actual = target.GetStreamData();
CompareByteArray(expected, actual);
target.Dispose();
indobj.Dispose();
}
public void Deleted_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
bool expected = false;
bool actual;
actual = target.Deleted;
Assert.AreEqual(expected, actual);
target.Deleted = true;
expected = true;
actual = target.Deleted;
Assert.AreEqual(expected, actual);
target.Dispose();
}
public void Generation_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
int expected = -1;
int actual;
actual = target.Generation;
Assert.AreEqual(expected, actual);
target.Generation = 1;
expected = 1;
actual = target.Generation;
Assert.AreEqual(expected, actual);
target.Dispose();
}
public void Number_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
int expected = -1;
int actual;
actual = target.Number;
Assert.AreEqual(expected, actual);
target.Number = 1;
expected = 1;
actual = target.Number;
Assert.AreEqual(expected, actual);
target.Dispose();
}
public void PDFStreamConstructor_Test1()
{
IStreamFilter[] filters = _usefilters;
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(filters, indobj);
Assert.IsNotNull(target);
StreamProxy proxy = (StreamProxy)target;
Assert.IsNotNull(proxy.InnerStreamProxy());
Assert.IsTrue(proxy.OwnsStreamProxy());
target.Dispose();
indobj.Dispose();
}
public void Offset_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
long expected = -1;
long actual;
actual = target.Offset;
Assert.AreEqual(expected, actual);
target.Offset = ((long)int.MaxValue) * 2L;
expected = ((long)int.MaxValue) * 2L;
actual = target.Offset;
Assert.AreEqual(expected, actual);
target.Dispose();
}
public void Generation_Test()
{
int generation = 1;
PDFXRefTable target = new XRefTableProxy(generation);
int actual;
actual = target.Generation;
Assert.AreEqual(generation, actual);
PDFIndirectObject obj = new PDFIndirectObject(this);
Assert.AreNotEqual(generation, obj.Generation);
target.Append(obj);
Assert.AreEqual(generation, obj.Generation);
obj.Dispose();
}
public void PDFIndirectObjectConstructor_Test()
{
PDFIndirectObject target = new PDFIndirectObject(this);
Assert.IsNotNull(target);
//Check the initialized values are empty
Assert.AreEqual(-1, target.Generation);
Assert.AreEqual(-1, target.Number);
Assert.AreEqual(-1L, target.Offset);
Assert.IsNotNull(target.ObjectData);
Assert.IsFalse(target.HasStream);
Assert.IsNull(target.Stream);
Assert.AreEqual(PDFObjectTypes.IndirectObject, target.Type);
Assert.IsFalse(target.Deleted);
target.Dispose();
}
public void Write_Test()
{
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(_usefilters, indobj);
byte[] expected = new byte[] { 0, 10, 1, 2, 3, 4, 5, 34, 35 };
target.Write(expected, 2, 5);
target.Flush();
byte[] actual = target.GetStreamData();
byte[] copied = new byte[5];
Array.Copy(expected, 2, copied, 0, 5);
CompareByteArray(copied, actual);
target.Dispose();
indobj.Dispose();
}
public void WriteLine_Test()
{
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream target = new StreamProxy(_usefilters, indobj);
string source = "Hello world";
target.WriteLine(source);
target.Flush();
byte[] actual = target.GetStreamData();
byte[] expected = System.Text.Encoding.ASCII.GetBytes(source + "\r\n");
CompareByteArray(expected, actual);
target.Dispose();
indobj.Dispose();
}
public void Add_Test()
{
PDFIndirectObject obj = new PDFIndirectObject(this);
int generation = 1;
PDFXRefTable target = new XRefTableProxy(generation);
int count = target.ReferenceCount;
int expected = 1; //Should return 1 as the first item.
int actual;
actual = target.Append(obj);
Assert.AreEqual(expected, actual);
//Check that it has set the IndirectObjects' values too.
Assert.AreEqual(target.Generation, obj.Generation);
Assert.AreEqual(actual, obj.Number);
Assert.AreEqual(-1L, obj.Offset);
//And check that it is in the list of references
Assert.AreEqual(count + 1, target.ReferenceCount);
Assert.IsTrue(target.Contains(obj));
//Add another and test
PDFIndirectObject obj2 = new PDFIndirectObject(this);
expected = 2;
actual = target.Append(obj);
Assert.AreEqual(expected, actual);
//Check that it has set the IndirectObjects' values too.
Assert.AreEqual(target.Generation, obj.Generation);
Assert.AreEqual(actual, obj.Number);
Assert.AreEqual(-1L, obj.Offset);
//And check that it is in the list of references
Assert.AreEqual(count + 2, target.ReferenceCount);
Assert.IsTrue(target.Contains(obj));
obj.Dispose();
obj2.Dispose();
}
public void WriteData_Test()
{
IStreamFilter[] filters = _usefilters;
PDFIndirectObject indobj = new PDFIndirectObject(this);
PDFStream stream = new StreamProxy(filters, indobj);
PDFWriter writer = null;
try
{
stream.WriteData(writer);
Assert.Fail("Expected an exception to be raised for PDFStream.WriteData()");
}
catch (NotSupportedException)
{
//Should raise an exception
}
stream.Dispose();
indobj.Dispose();
}
