public void Must_perform_encoding()
{
var systemUnderTest = new UrlEncoder();
string encodedUrl = systemUnderTest.Encode("?Test=1&Test=2\r");
Assert.That(encodedUrl, Is.EqualTo("%3fTest%3d1%26Test%3d2%0d"));
}
public void Ctor_WithNoParameters_DefaultsToBasicLatin()
{
// Arrange
UrlEncoder encoder = new UrlEncoder();
// Act & assert
Assert.Equal("a", encoder.UrlEncode("a"));
Assert.Equal("%C3%A9", encoder.UrlEncode("\u00E9" /* LATIN SMALL LETTER E WITH ACUTE */));
Assert.Equal("%E2%98%81", encoder.UrlEncode("\u2601" /* CLOUD */));
}
public void EncodeSubscriptionUpdate()
{
UrlEncoder urlEncoder = new UrlEncoder();
Subscription subscription = new Subscription();
subscription.Id = "sub_569df922b4506cd73030";
subscription.Offer = new Offer() { Id = "sub_569df922b4506cd73030" };
string expected = "offer=sub_569df922b4506cd73030";
string reply = urlEncoder.EncodeUpdate(subscription);
Assert.AreEqual(expected, reply);
}
public void Ctor_WithUnicodeRanges()
{
// Arrange
UrlEncoder encoder = new UrlEncoder(UnicodeRanges.Latin1Supplement, UnicodeRanges.MiscellaneousSymbols);
// Act & assert
Assert.Equal("%61", encoder.UrlEncode("a"));
Assert.Equal("\u00E9", encoder.UrlEncode("\u00E9" /* LATIN SMALL LETTER E WITH ACUTE */));
Assert.Equal("\u2601", encoder.UrlEncode("\u2601" /* CLOUD */));
}
public void EncodeTransactionUpdate()
{
UrlEncoder urlEncoder = new UrlEncoder();
Transaction transaction = new Transaction();
transaction.Token = "098f6bcd4621d373cade4e832627b4f6";
transaction.Amount = 3500;
transaction.Currency = "EUR";
transaction.Description = "Test";
string expected = "description=Test";
string reply = urlEncoder.EncodeUpdate(transaction);
Assert.AreEqual(expected, reply);
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
}
public TreeRouteBuilder(
ILoggerFactory loggerFactory,
UrlEncoder urlEncoder,
ObjectPool <UriBuildingContext> objectPool,
IInlineConstraintResolver constraintResolver)
: this(loggerFactory, objectPool, constraintResolver)
{
if (urlEncoder == null)
{
throw new ArgumentNullException(nameof(urlEncoder));
}
_urlEncoder = urlEncoder;
}
public PortfolioCommentController(ICommentServices commentServices,
IUserServices userServices,
IPortfolioServices portfolioServices,
HtmlEncoder htmlEncoder,
JavaScriptEncoder javascriptEncoder,
UrlEncoder urlEncoder)
{
_commentServices = commentServices;
_userServices = userServices;
_portfolioServices = portfolioServices;
_htmlEncoder = htmlEncoder;
_javaScriptEncoder = javascriptEncoder;
_urlEncoder = urlEncoder;
}
public ApiKeyAuthenticationHandler(
IOptionsMonitor <ApiKeyAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IUserApiKeyService userApiKeyService)
: base(options, logger, encoder, clock)
{
_userManager = userManager;
_signInManager = signInManager;
_userApiKeyService = userApiKeyService;
}
public TicketAuthenticationHandler(
IOptionsMonitor <TicketAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
IDataProtectionProvider dataProtection,
IDistributedCache cache
)
: base(options, logger, encoder, clock)
{
// _dp = dataProtection.CreateProtector($"_dp:{Assembly.GetEntryAssembly().FullName}");
_dp = dataProtection.CreateProtector(AppConstants.DataProtectionPurpose);
_cache = cache;
}
/// <summary>
/// Updates the asynchronous.
/// </summary>
/// <param name="obj">The object.</param>
/// <returns></returns>
public virtual async Task <T> UpdateAsync(T obj)
{
String resourceId = GetResourceId(obj);
var encoder = new UrlEncoder();
String paramStr = encoder.EncodeUpdate(obj);
var content = new StringContent(paramStr);
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
string requestUri = _apiUrl + "/" + _resource.ToString().ToLower() + "/" + resourceId;
HttpResponseMessage response = httpClient.PutAsync(requestUri, content).Result;
String data = await readReponseMessage(response);
return(ReadResult <T>(data));
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder, IHostingEnvironment environment)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_env = environment;
}
public BankIdHandler(
IOptionsMonitor <BankIdOptions> options,
ILoggerFactory loggerFactory,
UrlEncoder encoder,
ISystemClock clock,
IBankIdLoginOptionsProtector loginOptionsProtector,
IBankIdLoginResultProtector loginResultProtector,
IBankIdEventTrigger bankIdEventTrigger)
: base(options, loggerFactory, encoder, clock)
{
_loginOptionsProtector = loginOptionsProtector;
_loginResultProtector = loginResultProtector;
_bankIdEventTrigger = bankIdEventTrigger;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options"></param>
/// <param name="authenticationService"></param>
/// <param name="applicationService"></param>
/// <param name="roleService"></param>
/// <param name="logger"></param>
/// <param name="encoder"></param>
/// <param name="clock"></param>
public ErtisAuthAuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
IAuthenticationService authenticationService,
IApplicationService applicationService,
IRoleService roleService,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock) :
base(options, logger, encoder, clock)
{
this.authenticationService = authenticationService;
this.applicationService = applicationService;
this.roleService = roleService;
}
public BankIdAuthenticationHandler(
IOptionsMonitor <BankIdAuthenticationOptions> options,
ILoggerFactory loggerFactory,
UrlEncoder encoder,
ISystemClock clock,
ILogger <BankIdAuthenticationHandler> logger,
IBankIdLoginOptionsProtector loginOptionsProtector,
IBankIdLoginResultProtector loginResultProtector)
: base(options, loggerFactory, encoder, clock)
{
_logger = logger;
_loginOptionsProtector = loginOptionsProtector;
_loginResultProtector = loginResultProtector;
}
public BasicAuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
RoleManager <IdentityRole> roleManager,
UserManager <TUser> userManager,
SignInManager <TUser> signInManager)
: base(options, logger, encoder, clock)
{
_roleManager = roleManager;
_userManager = userManager;
_signInManager = signInManager;
}
public ManageController(
UserManager <User> userManager,
SignInManager <User> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
DatabaseContext context)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_databaseContext = context;
}
public ExperienceApiAuthenticationHandler(
IOptionsMonitor <ExperienceApiAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
DoctrinaAuthorizationDbContext authorizationDbContext,
IAuthorityContext authority,
IWebHostEnvironment environment
) : base(options, logger, encoder, clock)
{
_authorizationDbContext = authorizationDbContext;
_authority = authority;
_environment = environment;
}
public ManageController(
UserManager <AppUser> userManager,
SignInManager <AppUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder, IBillService billService)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_billService = billService;
}
private string ComputeSignature(string consumerSecret, string tokenSecret, string signatureData)
{
//log.LogDebug("ComputeSignature called with consumerSecret " + consumerSecret);
using (var algorithm = new HMACSHA1())
{
algorithm.Key = Encoding.ASCII.GetBytes(
string.Format(CultureInfo.InvariantCulture,
"{0}&{1}",
UrlEncoder.UrlEncode(consumerSecret),
string.IsNullOrEmpty(tokenSecret) ? string.Empty : UrlEncoder.UrlEncode(tokenSecret)));
var hash = algorithm.ComputeHash(Encoding.ASCII.GetBytes(signatureData));
return(Convert.ToBase64String(hash));
}
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder, IRunnerRepo runnerRepo, ICloudStorageService cloudStorageService)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_runnerRepo = runnerRepo;
_cloudStorageService = cloudStorageService;
}
public ManageController(
UserManager <AppUser> userManager,
SignInManager <AppUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
IdentityAppContext db)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_db = db;
}
public EnableAuthenticatorModel(
UserManager <ApplicationUser> userManager,
ILoggingServices loggingServices,
UrlEncoder urlEncoder)
{
_userManager = userManager;
_urlEncoder = urlEncoder;
#region Template
_loggingServices = loggingServices;
logModel = new LogModel();
userScopesModel = new UserScopesModel(HttpContext);
logModel.SetModel(userScopesModel.Subject.ToString(), userScopesModel.Name, nameof(EnableAuthenticatorModel), ApplicationNames.AuthorizationServer, LogTypeEnum.Info);
#endregion
}
public Cizelge1Controller(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
ApplicationDbContext context)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_context = context;
}
public ManageController(
ApplicationDbContext context,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILoggerFactory loggerFactory,
UrlEncoder urlEncoder)
{
_context = context;
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = loggerFactory.CreateLogger <ManageController>();
_urlEncoder = urlEncoder;
}
public ManageController(
UserManager <Staff> userManager,
SignInManager <Staff> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
ApplicationDbContext context,
UrlEncoder urlEncoder)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_context = context;
_urlEncoder = urlEncoder;
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
HospitalCMSContext context)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
db = context;
}
public IActionResult Create(string Slug, List list)
{
var user = _userManager.Users.FirstOrDefault(u => u.Slug == Slug);
if (user.Id == _userManager.GetUserId(User))
{
list.Slug = UrlEncoder.ListSlugSearch(_context, list, user.Id);
list.ApplicationUserId = user.Id;
_context.Lists.Add(list);
_context.SaveChanges();
TempData["message"] = $"{list.Name} has been created";
}
return(RedirectToAction(nameof(Index)));
}
public EnableAuthenticatorModel(
UserManager <IdentityUser> userManager,
ILogger <EnableAuthenticatorModel> logger,
UrlEncoder urlEncoder,
IStringLocalizerFactory factory)
{
_userManager = userManager;
_logger = logger;
_urlEncoder = urlEncoder;
var type = typeof(IdentityResource);
var assemblyName = new AssemblyName(type.GetTypeInfo().Assembly.FullName);
_identityLocalizer = factory.Create("IdentityResource", assemblyName.Name);
}
public AlfrescoAuthenticationHandler(
IOptionsMonitor <AlfrescoAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
ISimpleMemoryCache simpleMemoryCache,
IAlfrescoHttpClient alfrescoHttpClient,
IMapper mapper,
IAlfrescoConfiguration alfrescoConfiguration) : base(options, logger, encoder, clock)
{
_simpleMemoryCache = simpleMemoryCache;
_alfrescoHttpClient = alfrescoHttpClient;
_mapper = mapper;
_alfrescoConfiguration = alfrescoConfiguration;
}
public ManageController(
UserManager <AppUser> userManager,
SignInManager <AppUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
UsersDbContext dbContext)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_dbContext = dbContext;
}
public LinkedInAuthenticationMiddleware(
[NotNull] RequestDelegate next,
[NotNull] IDataProtectionProvider dataProtectionProvider,
[NotNull] ILoggerFactory loggerFactory,
[NotNull] UrlEncoder encoder,
[NotNull] IOptions <SharedAuthenticationOptions> sharedOptions,
[NotNull] IOptions <LinkedInAuthenticationOptions> options)
: base(next, dataProtectionProvider, loggerFactory, encoder, sharedOptions, options)
{
if (Options.Fields.Count != 0 && !Options.UserInformationEndpoint.Contains("~"))
{
throw new ArgumentException("The user information endpoint is improperly formatted. " +
"The endpoint must contain a '~' to append the supplied fields.", nameof(options));
}
}
public void ThrowWhenDesinationIsSmaller()
{
var input = GetBytes("/test%20test");
var destination = new Span <byte>(new byte[input.Length - 1]);
try
{
UrlEncoder.Decode(input, destination);
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentException);
}
}
public ManageController(
UserManager <User> userManager,
SignInManager <User> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
IManageService manage)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
this.manage = manage;
}
public void Ctor_WithCodePointFilter()
{
// Arrange
var filter = new CodePointFilter().AllowCharacters("ab").AllowCharacters('\0', '&', '\uFFFF', 'd');
UrlEncoder encoder = new UrlEncoder(filter);
// Act & assert
Assert.Equal("a", encoder.UrlEncode("a"));
Assert.Equal("b", encoder.UrlEncode("b"));
Assert.Equal("%63", encoder.UrlEncode("c"));
Assert.Equal("d", encoder.UrlEncode("d"));
Assert.Equal("%00", encoder.UrlEncode("\0")); // we still always encode control chars
Assert.Equal("%26", encoder.UrlEncode("&")); // we still always encode HTML-special chars
Assert.Equal("%EF%BF%BF", encoder.UrlEncode("\uFFFF")); // we still always encode non-chars and other forbidden chars
}
public ManageController(
UserManager <User> userManager,
SignInManager <User> signInManager,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory,
UrlEncoder urlEncoder)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <ManageController>();
_urlEncoder = urlEncoder;
}
public void EncodeNullableObject()
{
UrlEncoder urlEncoder = new UrlEncoder();
DateTime? trialEnd = null;
String encodedObject = urlEncoder.EncodeObject(new
{
Offer = "OfferId",
Payment = "PaymentId",
Client = "clientId",
Start_At = "1395266400",
End_At = trialEnd
});
Assert.IsNotNull(encodedObject);
Assert.AreEqual(encodedObject, "offer=OfferId&payment=PaymentId&client=clientId&start_at=1395266400");
}
/// <summary>
/// Create an HttpClientRest-object
/// </summary>
/// <param name="apiUrl">API Endpoint URL</param>
/// <param name="apiKey">Private key</param>
public HttpClientRest(string apiUrl, string apiKey)
{
this._apiUrl = apiUrl;
this._apiKey = apiKey;
try
{
Uri uri = new Uri(apiUrl);
}
catch
{
throw new PaymillException("ApiURL is not a valid format Uri");
}
this._urlEncoder = new UrlEncoder();
}
public void Default_EquivalentToBasicLatin()
{
// Arrange
UrlEncoder controlEncoder = new UrlEncoder(UnicodeRanges.BasicLatin);
UrlEncoder testEncoder = UrlEncoder.Default;
// Act & assert
for (int i = 0; i <= Char.MaxValue; i++)
{
if (!IsSurrogateCodePoint(i))
{
string input = new String((char)i, 1);
Assert.Equal(controlEncoder.UrlEncode(input), testEncoder.UrlEncode(input));
}
}
}
public void EncodeNullableIntObject()
{
UrlEncoder urlEncoder = new UrlEncoder();
int? trialPeriodDays = 100;
int? trialPeriodMinutes = null;
String encodedObject = urlEncoder.EncodeObject(new
{
Amount = "amount",
Currency = "currency",
Interval = "interval",
Name = "name",
Trial_Period_Days = trialPeriodDays,
Trial_Period_Minutes = trialPeriodMinutes
});
Assert.IsNotNull(encodedObject);
Assert.AreEqual(encodedObject, "amount=amount¤cy=currency&interval=interval&name=name&trial_period_days=100");
}
public UrlEncodingVisitor(UrlEncoder base_encoder, UrlEncode encode)
{
this.base_encoder = base_encoder;
this.encode = encode;
}
public void EncodeClientOrder()
{
UrlEncoder urlEncoder = new UrlEncoder();
Client.Order order = Client.CreateOrder();
order.ByCreatedAt().Asc();
String encodedObject = urlEncoder.EncodeFilterParameters(null, order, 20, 9);
Assert.IsNotNull(encodedObject);
Assert.AreEqual(encodedObject, "order=created_at_asc&count=20&offset=9");
}
public void UrlEncode_DoesNotOutputHtmlSensitiveCharacters()
{
// Per the design document, we provide additional defense-in-depth
// by never emitting HTML-sensitive characters unescaped.
// Arrange
UrlEncoder urlEncoder = new UrlEncoder(UnicodeRanges.All);
HtmlEncoder htmlEncoder = new HtmlEncoder(UnicodeRanges.All);
// Act & assert
for (int i = 0; i <= 0x10FFFF; i++)
{
if (IsSurrogateCodePoint(i))
{
continue; // surrogates don't matter here
}
string urlEncoded = urlEncoder.UrlEncode(Char.ConvertFromUtf32(i));
string thenHtmlEncoded = htmlEncoder.HtmlEncode(urlEncoded);
Assert.Equal(urlEncoded, thenHtmlEncoded); // should have contained no HTML-sensitive characters
}
}
public void UrlEncode_StringSubstring()
{
// Arrange
UrlEncoder encoder = new UrlEncoder();
var output = new StringWriter();
// Act
encoder.UrlEncode("Hello+world!", 3, 5, output);
// Assert
Assert.Equal("lo%2Bwo", output.ToString());
}
public void UrlEncode_NullInput_ReturnsNull()
{
// Arrange
UrlEncoder encoder = new UrlEncoder();
Assert.Throws<ArgumentNullException>(() => { encoder.UrlEncode(null); });
}
public void UrlEncode_BadSurrogates_ReturnsUnicodeReplacementChar()
{
// Arrange
UrlEncoder encoder = new UrlEncoder(UnicodeRanges.All); // allow all codepoints
// "a<unpaired leading>b<unpaired trailing>c<trailing before leading>d<unpaired trailing><valid>e<high at end of string>"
const string input = "a\uD800b\uDFFFc\uDFFF\uD800d\uDFFF\uD800\uDFFFe\uD800";
const string expected = "a%EF%BF%BDb%EF%BF%BDc%EF%BF%BD%EF%BF%BDd%EF%BF%BD%F0%90%8F%BFe%EF%BF%BD"; // 'D800' 'DFFF' was preserved since it's valid
// Act
string retVal = encoder.UrlEncode(input);
// Assert
Assert.Equal(expected, retVal);
}
public void UrlEncode_AllRangesAllowed_StillEncodesForbiddenChars()
{
// Arrange
UrlEncoder encoder = new UrlEncoder(UnicodeRanges.All);
// Act & assert - BMP chars
for (int i = 0; i <= 0xFFFF; i++)
{
string input = new String((char)i, 1);
string expected;
if (IsSurrogateCodePoint(i))
{
expected = "%EF%BF%BD"; // unpaired surrogate -> Unicode replacement char
}
else
{
bool mustEncode = true;
// RFC 3987, Sec. 2.2 gives the list of allowed chars
// (We allow 'ipchar' except for "'", "&", "+", "%", and "="
if (('a' <= i && i <= 'z') || ('A' <= i && i <= 'Z') || ('0' <= i && i <= '9'))
{
mustEncode = false; // ALPHA / DIGIT
}
else if ((0x00A0 <= i && i <= 0xD7FF) | (0xF900 <= i && i <= 0xFDCF) | (0xFDF0 <= i && i <= 0xFFEF))
{
mustEncode = !UnicodeHelpers.IsCharacterDefined((char)i); // 'ucschar'
}
else
{
switch (i)
{
// iunreserved
case '-':
case '.':
case '_':
case '~':
// isegment-nz-nc
case '@':
// sub-delims
case '!':
case '$':
case '(':
case ')':
case '*':
case ',':
case ';':
mustEncode = false;
break;
}
}
if (mustEncode)
{
expected = GetKnownGoodPercentEncodedValue(i);
}
else
{
expected = input; // no encoding
}
}
string retVal = encoder.UrlEncode(input);
Assert.Equal(expected, retVal);
}
// Act & assert - astral chars
for (int i = 0x10000; i <= 0x10FFFF; i++)
{
string input = Char.ConvertFromUtf32(i);
string expected = GetKnownGoodPercentEncodedValue(i);
string retVal = encoder.UrlEncode(input);
Assert.Equal(expected, retVal);
}
}
public void UrlEncode_EmptyStringInput_ReturnsEmptyString()
{
// Arrange
UrlEncoder encoder = new UrlEncoder();
// Act & assert
Assert.Equal("", encoder.UrlEncode(""));
}
public void UrlEncode_InputDoesNotRequireEncoding_ReturnsOriginalStringInstance()
{
// Arrange
UrlEncoder encoder = new UrlEncoder();
string input = "Hello,there!";
// Act & assert
Assert.Same(input, encoder.UrlEncode(input));
}
public void EncodeClientFilter()
{
UrlEncoder urlEncoder = new UrlEncoder();
Client.Filter filter = Client.CreateFilter();
filter.ByEmail("*****@*****.**");
filter.ByPayment("_pay12345678");
filter.BySubscriptionId("_subs12345678");
filter.ByOfferId("_offery12345678");
filter.ByCreatedAt(unixEpoch.AddSeconds(1340199740), unixEpoch.AddSeconds(1340199741));
filter.ByUpdatedAt(unixEpoch.AddSeconds(1385145851), unixEpoch.AddSeconds(1385145851));
String encodedObject = urlEncoder.EncodeFilterParameters(filter, null, 20, 9);
Assert.IsNotNull(encodedObject);
Assert.AreEqual(encodedObject, "payment=_pay12345678&subscription=_subs12345678&offer=_offery12345678&email=john.rambo%40qaiware.com&created_at=1340199740-1340199741&updated_at=1385145851-1385145851&count=20&offset=9");
}
