public void ToStringTest1()
{
var tif = Tif.Load(testFilePath);
string foo = tif[0].ToString();
Assert.False(string.IsNullOrEmpty(foo));
}
public void SaveToStreamNull()
{
var tif = Tif.Load(testFilePath);
MemoryStream stream = null;
Assert.Throws <ArgumentNullException>(() => tif.Save(stream));
}
public void ReadNonExistingField()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
Assert.Throws <KeyNotFoundException>(() => page[TagType.AliasLayerMetadata]);
}
public void LoadFromStreamNull()
{
FileStream stream = null;
using (stream)
Assert.Throws <ArgumentNullException>(() => Tif.Load(stream));
}
public void CopyAndModifyPages()
{
string originalName = Path.Combine("testfiles", "4.2.04.tiff");
string newName = Path.Combine("output", "copiedpages_2.tif");
var newTif = new Tif();
var tif = Tif.Load(originalName);
newTif.Add(tif[0]);
newTif.Add(tif[0]);
var values = new ushort[] { 0, 2 };
var tag = new Field(TagType.PageNumber, FieldType.Short, values);
newTif[0].Add(tag);
tag = new Field(TagType.PageNumber, FieldType.Short, new ushort[] { 1, 2 });
newTif[1].Add(tag);
newTif.Save(newName);
newTif = Tif.Load(newName);
Assert.Equal(2, newTif.Count);
ushort[] pageNumber;
pageNumber = (ushort[])newTif[0][TagType.PageNumber].Values;
Assert.Equal(0, pageNumber[0]);
Assert.Equal(2, pageNumber[1]);
pageNumber = (ushort[])newTif[1][TagType.PageNumber].Values;
Assert.Equal(1, pageNumber[0]);
Assert.Equal(2, pageNumber[1]);
}
public void HasFieldTestFalse()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
Assert.False(page.Contains(TagType.TargetPrinter));
}
public void SetPagenumbersTest()
{
var tif = Tif.Load(Path.Combine("testfiles", "Multi_page24bpp.tif"));
tif.SetPageNumbers();
tif.Save(Path.Combine("output", "paged.tif"));
}
public void HasFieldTestTrue()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
Assert.True(page.Contains(TagType.NewSubfileType));
}
public void CopyTest()
{
Tif original = Tif.Load(testFilePath);
Tif copy = original.Copy();
Assert.NotSame(original, copy);
}
public void BaselineAsciiFields()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
Assert.Equal("Adobe Photoshop CS2 Windows", page.Software);
Assert.Equal("2009:04:07 18:33:11", page.DateTime);
}
public void LoadFromFile()
{
Tif tif;
tif = Tif.Load(testFilePath);
Assert.IsType <Tif>(tif);
}
public void AddTest()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
page.Add(TagType.Predictor, Predictor.NoPredictionScheme);
page.Add(TagType.NewSubfileType, NewSubfileType.Page | NewSubfileType.ReducedResolutionVersion | NewSubfileType.TransparencyMask);
}
public void LoadFromStream()
{
Tif tif;
using (var stream = new FileStream(testFilePath, FileMode.Open))
tif = Tif.Load(stream);
Assert.IsType <Tif>(tif);
}
public void StripsPerImageTest()
{
var tif = Tif.Load(testFilePath);
Page target = tif[0];
uint actual;
actual = target.StripsPerImage;
Assert.Equal((uint)1, actual);
}
public void RemovePage()
{
var tif = Tif.Load(testFilePath);
int numPages = tif.Count;
tif.RemoveAt(0);
Assert.Equal(numPages - 1, tif.Count);
}
public void DuplicatePage()
{
var tif = Tif.Load(testFilePath);
int numPages = tif.Count;
tif.Add(tif[0]);
Assert.Equal(numPages + 1, tif.Count);
}
public static void SetPageNumbers(this Tif tif)
{
ushort total = (ushort)tif.Count;
for (ushort i = 0; i < total; i++)
{
tif[i].PageNumber = i;
tif[i].PageTotal = total;
}
}
public void LoadFromBytes()
{
Tif tif;
byte[] bytes = File.ReadAllBytes(testFilePath);
tif = Tif.Load(bytes);
Assert.IsType <Tif>(tif);
}
public void GetAsciiFieldValueTest()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
string expected = string.Empty;
string actual;
actual = page.GetAsciiFieldValue(TagType.PageName);
Assert.Equal(expected, actual);
}
public void FillOrderTest()
{
var tif = Tif.Load(testFilePath);
Page target = tif[0];
FillOrder expected = FillOrder.LowBitsFirst;
FillOrder actual;
target.FillOrder = expected;
actual = target.FillOrder;
Assert.Equal(expected, actual);
}
public void GrayResponseCurveTest()
{
var tif = Tif.Load(testFilePath);
Page target = tif[0];
ushort[] expected = new ushort[8];
ushort[] actual;
target.GrayResponseCurve = expected;
actual = target.GrayResponseCurve;
Assert.Equal(expected, actual);
}
public void GetData()
{
Tif tif;
tif = Tif.Load(testFilePath);
byte[] buffer = tif.GetData();
tif = Tif.Load(buffer);
Assert.IsType <Tif>(tif);
}
public void StripOffsetsTest()
{
var tif = Tif.Load(testFilePath);
Page target = tif[0];
uint[] expected = new uint[] { 23860 };
uint[] actual;
target.StripOffsets = expected;
actual = target.StripOffsets;
Assert.Equal(expected, actual);
}
public void CopyTest()
{
var tif = Tif.Load(testFilePath);
var original = tif[0];
var copy = original.Copy();
Assert.Equal(original.Count, copy.Count);
foreach (var tag in original)
{
Assert.True(copy.Contains(tag.TagType));
}
}
private static void Dump(string file)
{
try
{
Console.WriteLine(Tif.Load(file));
}
catch (Exception ex)
{
Console.Error.WriteLine("Exception loading file: " + file);
Console.Error.WriteLine(ex.ToString());
}
}
public void SaveToFile()
{
Tif tif;
tif = Tif.Load(testFilePath);
string path = Path.Combine("output", "TIFF_file_format_test.new");
tif.Save(path);
tif = Tif.Load(path);
Assert.IsType <Tif>(tif);
}
private void SendResponse(Tif tifValue, bool includeCpsUrl = false)
{
var responseMessageBuilder = new StringBuilder();
var nut = GenerateNut(Options.EncryptionKey);
StoreNut(nut);
responseMessageBuilder.AppendLine("ver=1", true);
responseMessageBuilder.AppendLine("nut=" + nut, true);
responseMessageBuilder.AppendLine("tif=" + tifValue.ToString("X"), true);
responseMessageBuilder.AppendLine("qry=" + Request.Path + "?nut=" + nut, true);
if (includeCpsUrl)
{
responseMessageBuilder.AppendLine("url=" + Request.Scheme + "://" + Request.Host + Request.Path + "?cps=" + GenerateCpsCode(), true);
}
if ((tifValue.HasFlag(Tif.IdMatch) || tifValue.HasFlag(Tif.PreviousIdMatch) || tifValue.HasFlag(Tif.SqrlDisabled)))
{
var idk = GetClientParams()["idk"];
var suk = Options.GetUserSukInternal(idk, Request.HttpContext);
//Removed Base64 Encoding for SUK which was causing a validation error on VUK / URS
responseMessageBuilder.AppendLine($"suk={suk}", true);
}
if (!(tifValue.HasFlag(Tif.TransientError) || tifValue.HasFlag(Tif.BadId) ||
tifValue.HasFlag(Tif.ClientFailed) || tifValue.HasFlag(Tif.CommandFailed) ||
tifValue.HasFlag(Tif.FunctionNotSupported)) && GetCommand() != Command.Query)
{
NoneQueryOptionHandling();
}
if (GetCommand() == Command.Query && tifValue.HasFlag(Tif.IdMatch) && (Options.GetAskQuestion != null || Options.GetAskQuestionAsync != null))
{
var message = Options.GetAskQuestionInternal(Request, nut);
if (message != null)
{
responseMessageBuilder.AppendLine($"ask={message.ToAskMessage()}", true);
}
}
var responseMessageBytes = Encoding.ASCII.GetBytes(Base64UrlTextEncoder.Encode(Encoding.ASCII.GetBytes(responseMessageBuilder.ToString())));
Response.ContentType = "application/x-www-form-urlencoded";
Response.StatusCode = StatusCodes.Status200OK;
Response.ContentLength = responseMessageBytes.LongLength;
Response.Body.WriteAsync(responseMessageBytes, 0, responseMessageBytes.Length);
if (Options.Diagnostics)
{
SqrlAuthenticationOptions.LogTransaction(Request, responseMessageBuilder.ToString());
}
}
public void ReadExistingField()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
var tag = page[TagType.ImageWidth];
Assert.NotNull(tag);
Assert.Equal(FieldType.Short, tag.FieldType);
Assert.Single(tag.Values);
var values = (ushort[])tag.Values;
Assert.Equal(288, values[0]);
}
public void BitsPerSample()
{
var tif = Tif.Load(testFilePath);
var page = tif[0];
ushort bitsper = 42;
page.BitsPerSample = bitsper;
var tag = page[TagType.BitsPerSample];
var values = (ushort[])tag.Values;
Assert.Equal(bitsper, values[0]);
}
public void SaveToStream()
{
Tif tif;
tif = Tif.Load(testFilePath);
using (MemoryStream stream = new MemoryStream())
{
tif.Save(stream);
stream.Position = 0;
tif = Tif.Load(stream);
}
Assert.IsType <Tif>(tif);
}
