text:
<?php

use Symfony\Component\Translation\MessageCatalogue;

$catalogue = new MessageCatalogue('tr', array (
  'validators' =>
  array (
    'This value should be false.' => 'Bu değer olumsuz olmalıdır.',
    'This value should be true.' => 'Bu değer olumlu olmalıdır.',
    'This value should be of type {{ type }}.' => 'Bu değerin tipi {{ type }} olmalıdır.',
    'This value should be blank.' => 'Bu değer boş olmalıdır.',
    'The value you selected is not a valid choice.' => 'Seçtiğiniz değer geçerli bir seçenek değil.',
    'You must select at least {{ limit }} choice.|You must select at least {{ limit }} choices.' => 'En az {{ limit }} seçenek belirtmelisiniz.',
    'You must select at most {{ limit }} choice.|You must select at most {{ limit }} choices.' => 'En çok {{ limit }} seçenek belirtmelisiniz.',
    'One or more of the given values is invalid.' => 'Verilen değerlerden bir veya daha fazlası geçersiz.',
    'This field was not expected.' => 'Bu alan beklenen olmadı.',
    'This field is missing.' => 'Bu alan, eksik',
    'This value is not a valid date.' => 'Bu değer doğru bir tarih biçimi değildir.',
    'This value is not a valid datetime.' => 'Bu değer doğru bir tarihsaat biçimi değildir.',
    'This value is not a valid email address.' => 'Bu değer doğru bir e-mail adresi değildir.',
    'The file could not be found.' => 'Dosya bulunamadı.',
    'The file is not readable.' => 'Dosya okunabilir değil.',
    'The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Dosya çok büyük ({{ size }} {{ suffix }}). İzin verilen en büyük dosya boyutu {{ limit }} {{ suffix }}.',
    'The mime type of the file is invalid ({{ type }}). Allowed mime types are {{ types }}.' => 'Dosyanın mime tipi geçersiz ({{ type }}). İzin verilen mime tipleri {{ types }}.',
    'This value should be {{ limit }} or less.' => 'Bu değer {{ limit }} ve altında olmalıdır.',
    'This value is too long. It should have {{ limit }} character or less.|This value is too long. It should have {{ limit }} characters or less.' => 'Bu değer çok uzun. {{ limit }} karakter veya daha az olmalıdır.',
    'This value should be {{ limit }} or more.' => 'Bu değer {{ limit }} veya daha fazla olmalıdır.',
    'This value is too short. It should have {{ limit }} character or more.|This value is too short. It should have {{ limit }} characters or more.' => 'Bu değer çok kısa. {{ limit }} karakter veya daha fazla olmaldır.',
    'This value should not be blank.' => 'Bu değer boş bırakılmamalıdır.',
    'This value should not be null.' => 'Bu değer boş bırakılmamalıdır.',
    'This value should be null.' => 'Bu değer boş bırakılmalıdır.',
    'This value is not valid.' => 'Bu değer geçerli değil.',
    'This value is not a valid time.' => 'Bu değer doğru bir saat değil.',
    'This value is not a valid URL.' => 'Bu değer doğru bir URL değil.',
    'The two values should be equal.' => 'İki değer eşit olmalıdır.',
    'The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Dosya çok büyük. İzin verilen en büyük dosya boyutu {{ limit }} {{ suffix }}.',
    'The file is too large.' => 'Dosya çok büyük.',
    'The file could not be uploaded.' => 'Dosya yüklenemiyor.',
    'This value should be a valid number.' => 'Bu değer geçerli bir rakam olmalıdır.',
    'This file is not a valid image.' => 'Bu dosya geçerli bir resim değildir.',
    'This is not a valid IP address.' => 'Bu geçerli bir IP adresi değildir.',
    'This value is not a valid language.' => 'Bu değer geçerli bir lisan değil.',
    'This value is not a valid locale.' => 'Bu değer geçerli bir yer değildir.',
    'This value is not a valid country.' => 'Bu değer geçerli bir ülke değildir.',
    'This value is already used.' => 'Bu değer şu anda kullanımda.',
    'The size of the image could not be detected.' => 'Resmin boyutu saptanamıyor.',
    'The image width is too big ({{ width }}px). Allowed maximum width is {{ max_width }}px.' => 'Resmin genişliği çok büyük ({{ width }}px). İzin verilen en büyük genişlik {{ max_width }}px.',
    'The image width is too small ({{ width }}px). Minimum width expected is {{ min_width }}px.' => 'Resmin genişliği çok küçük ({{ width }}px). En az {{ min_width }}px olmalıdır.',
    'The image height is too big ({{ height }}px). Allowed maximum height is {{ max_height }}px.' => 'Resmin yüksekliği çok büyük ({{ height }}px). İzin verilen en büyük yükseklik {{ max_height }}px.',
    'The image height is too small ({{ height }}px). Minimum height expected is {{ min_height }}px.' => 'Resmin yüksekliği çok küçük ({{ height }}px). En az {{ min_height }}px olmalıdır.',
    'This value should be the user\'s current password.' => 'Bu değer kullanıcının şu anki şifresi olmalıdır.',
    'This value should have exactly {{ limit }} character.|This value should have exactly {{ limit }} characters.' => 'Bu değer tam olarak {{ limit }} karakter olmaldır.',
    'The file was only partially uploaded.' => 'Dosya sadece kısmen yüklendi.',
    'No file was uploaded.' => 'Hiçbir dosya yüklenmedi.',
    'No temporary folder was configured in php.ini.' => 'php.ini içerisinde geçici dizin tanımlanmadı.',
    'Cannot write temporary file to disk.' => 'Geçici dosya diske yazılamıyor.',
    'A PHP extension caused the upload to fail.' => 'Bir PHP eklentisi dosyanın yüklemesini başarısız kıldı.',
    'This collection should contain {{ limit }} element or more.|This collection should contain {{ limit }} elements or more.' => 'Bu derlem {{ limit }} veya daha çok eleman içermelidir.',
    'This collection should contain {{ limit }} element or less.|This collection should contain {{ limit }} elements or less.' => 'Bu derlem {{ limit }} veya daha az eleman içermelidir.',
    'This collection should contain exactly {{ limit }} element.|This collection should contain exactly {{ limit }} elements.' => 'Bu derlem {{ limit }} eleman içermelidir.',
    'Invalid card number.' => 'Geçersiz kart numarası.',
    'Unsupported card type or invalid card number.' => 'Desteklenmeyen kart tipi veya geçersiz kart numarası.',
    'fos_user.username.already_used' => 'Kullanıcı adı zaten kullanılıyor',
    'fos_user.username.blank' => 'Lütfen bir kullanıcı adı girin',
    'fos_user.username.short' => '[-Inf,Inf]Kullanıcı adı çok kısa',
    'fos_user.username.long' => '[-Inf,Inf]Kullanıcı adı çok uzun',
    'fos_user.email.already_used' => 'e-posta zaten kullanılıyor',
    'fos_user.email.blank' => 'Lütfen bir e-posta girin',
    'fos_user.email.short' => '[-Inf,Inf]e-posta çok kısa',
    'fos_user.email.long' => '[-Inf,Inf]e-posta çok uzun',
    'fos_user.email.invalid' => 'e-posta geçerli değil',
    'fos_user.password.blank' => 'Lütfen bir parola girin',
    'fos_user.password.short' => '[-Inf,Inf]Parola çok kısa',
    'fos_user.new_password.blank' => 'Lütfen yeni parolayı girin',
    'fos_user.new_password.short' => '[-Inf,Inf]Yeni parola çok kısa',
    'fos_user.current_password.invalid' => 'Girilen parola geçersiz',
    'fos_user.group.blank' => 'Lütfen bir isim girin',
    'fos_user.group.short' => '[-Inf,Inf]İsim çok kısa',
    'fos_user.group.long' => '[-Inf,Inf]İsim çok uzun',
  ),
  'security' =>
  array (
    'An authentication exception occurred.' => 'Bir yetkilendirme istisnası oluştu.',
    'Authentication credentials could not be found.' => 'Kimlik bilgileri bulunamadı.',
    'Authentication request could not be processed due to a system problem.' => 'Bir sistem hatası nedeniyle yetkilendirme isteği işleme alınamıyor.',
    'Invalid credentials.' => 'Geçersiz kimlik bilgileri.',
    'Cookie has already been used by someone else.' => 'Çerez bir başkası tarafından zaten kullanılmıştı.',
    'Not privileged to request the resource.' => 'Kaynak talebi için imtiyaz bulunamadı.',
    'Invalid CSRF token.' => 'Geçersiz CSRF fişi.',
    'Digest nonce has expired.' => 'Derleme zaman aşımına uğradı.',
    'No authentication provider found to support the authentication token.' => 'Yetkilendirme fişini destekleyecek yetkilendirme sağlayıcısı bulunamadı.',
    'No session available, it either timed out or cookies are not enabled.' => 'Oturum bulunamadı, zaman aşımına uğradı veya çerezler etkin değil.',
    'No token could be found.' => 'Fiş bulunamadı.',
    'Username could not be found.' => 'Kullanıcı adı bulunamadı.',
    'Account has expired.' => 'Hesap zaman aşımına uğradı.',
    'Credentials have expired.' => 'Kimlik bilgileri zaman aşımına uğradı.',
    'Account is disabled.' => 'Hesap engellenmiş.',
    'Account is locked.' => 'Hesap kilitlenmiş.',
  ),
  'FOSUserBundle' =>
  array (
    'group.edit.submit' => 'Grubu Güncelle',
    'group.show.name' => 'Grup Adı',
    'group.new.submit' => 'Grup Yarat',
    'group.flash.updated' => 'Grup Güncellendi',
    'group.flash.created' => 'Grup Yaratıldı',
    'group.flash.deleted' => 'Grup Silindi',
    'security.login.username' => 'Kullanıcı adı',
    'security.login.password' => 'Parola',
    'security.login.remember_me' => 'Beni hatırla',
    'security.login.submit' => 'Giriş',
    'profile.show.username' => 'Kullanıcı adı',
    'profile.show.email' => 'E-posta adresi',
    'profile.edit.submit' => 'Güncelle',
    'profile.flash.updated' => 'Profil Güncellendi',
    'change_password.submit' => 'Parolayı Değiştir',
    'change_password.flash.success' => 'Parola değiştirildi',
    'registration.check_email' => '%email% adresine hesabınızı aktive etmek için kullanacağınız aktivasyon linkini barındıran bir e-posta gönderildi.',
    'registration.confirmed' => 'Tebrikler %username%. Hesabınız şu anda aktifleştirildi.',
    'registration.back' => 'Asıl sayfaya geri dön.',
    'registration.submit' => 'Kayıt ol',
    'registration.flash.user_created' => 'Kullanıcı başarıyla yaratıldı',
    'registration.email.subject' => 'Hoşgeldin %username%!',
    'registration.email.message' => 'Hoşgeldiniz %username%!

Hesabınızın aktivasyonunu tamamlamak için lütfen  %confirmationUrl%
adresini ziyaret ediniz.

Teşekkürler,
Web Takımı.
',
    'resetting.password_already_requested' => 'Son 24 saat içerisinde bu kullanıcı parola için istekte bulunmuş.',
    'resetting.check_email' => '%email% adresine parolanızı sıfırlama adresi bulunan bir e-posta gönderildi.',
    'resetting.request.invalid_username' => '%username% şeklinde bir kullanıcı adı ya da e-posta adresi bulunamadı.',
    'resetting.request.username' => 'Kullanıcı adı ya da e-posta adresi',
    'resetting.request.submit' => 'Parolayı Sıfırla',
    'resetting.reset.submit' => 'Parolayı değiştir',
    'resetting.flash.success' => 'Parola başarıyla değiştirildi',
    'resetting.email.subject' => 'Parola Yenileme',
    'resetting.email.message' => 'Merhaba  %username%!

Parolanızı yenilemek için  %confirmationUrl%
adresini ziyaret ediniz.

Teşekkürler,
Web Takımı.
',
    'layout.logout' => 'Çıkış',
    'layout.login' => 'Giriş',
    'layout.register' => 'Kayıt ol',
    'layout.logged_in_as' => '%username% olarak giriş yapıldı',
    'form.group_name' => 'Gurup Adı',
    'form.username' => 'Kullanıcı adı',
    'form.email' => 'E-posta adresi',
    'form.current_password' => 'Geçerli Parola',
    'form.password' => 'Parola',
    'form.password_confirmation' => 'Onay',
    'form.new_password' => 'Yeni Parola',
    'form.new_password_confirmation' => 'Onay',
  ),
));

$catalogueLt = new MessageCatalogue('lt', array (
  'validators' =>
  array (
    'This value should be false.' => 'Reikšmė turi būti neigiama.',
    'This value should be true.' => 'Reikšmė turi būti teigiama.',
    'This value should be of type {{ type }}.' => 'Šios reikšmės tipas turi būti {{ type }}.',
    'This value should be blank.' => 'Ši reikšmė turi būti tuščia.',
    'The value you selected is not a valid choice.' => 'Neteisingas pasirinkimas.',
    'You must select at least {{ limit }} choice.|You must select at least {{ limit }} choices.' => 'Turite pasirinkti bent {{ limit }} variantą.|Turite pasirinkti bent {{ limit }} variantus.|Turite pasirinkti bent {{ limit }} variantų.',
    'You must select at most {{ limit }} choice.|You must select at most {{ limit }} choices.' => 'Turite pasirinkti ne daugiau kaip {{ limit }} variantą.|Turite pasirinkti ne daugiau kaip {{ limit }} variantus.|Turite pasirinkti ne daugiau kaip {{ limit }} variantų.',
    'One or more of the given values is invalid.' => 'Viena ar daugiau įvestų reikšmių yra netinkamos.',
    'This field was not expected.' => 'Nebuvo tikimasi Šis laukas.',
    'This field is missing.' => 'Šiame lauke yra dingęs.',
    'This value is not a valid date.' => 'Ši reikšmė nėra data.',
    'This value is not a valid datetime.' => 'Ši reikšmė nera data ir laikas.',
    'This value is not a valid email address.' => 'Ši reikšmė nėra tinkamas el. pašto adresas.',
    'The file could not be found.' => 'Byla nerasta.',
    'The file is not readable.' => 'Negalima nuskaityti bylos.',
    'The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Byla yra per didelė ({{ size }} {{ suffix }}). Maksimalus dydis {{ limit }} {{ suffix }}.',
    'The mime type of the file is invalid ({{ type }}). Allowed mime types are {{ types }}.' => 'Netinkamas bylos tipas (mime type) ({{ type }}). Galimi bylų tipai {{ types }}.',
    'This value should be {{ limit }} or less.' => 'Reikšmė turi būti {{ limit }} arba mažiau.',
    'This value is too long. It should have {{ limit }} character or less.|This value is too long. It should have {{ limit }} characters or less.' => 'Per didelis simbolių skaičius. Turi susidaryti iš {{ limit }} arba mažiau simbolių.|Per didelis simbolių skaičius. Turi susidaryti iš {{ limit }} arba mažiau simbolių.|Per didelis simbolių skaičius. Turi susidaryti iš {{ limit }} arba mažiau simbolių.',
    'This value should be {{ limit }} or more.' => 'Reikšmė turi būti {{ limit }} arba daugiau.',
    'This value is too short. It should have {{ limit }} character or more.|This value is too short. It should have {{ limit }} characters or more.' => 'Per mažas simbolių skaičius. Turi susidaryti iš {{ limit }} arba daugiau simbolių.|Per mažas simbolių skaičius. Turi susidaryti iš {{ limit }} arba daugiau simbolių.|Per mažas simbolių skaičius. Turi susidaryti iš {{ limit }} arba daugiau simbolių.',
    'This value should not be blank.' => 'Ši reikšmė negali būti tuščia.',
    'This value should not be null.' => 'Ši reikšmė negali būti null.',
    'This value should be null.' => 'Ši reikšmė turi būti null.',
    'This value is not valid.' => 'Netinkama reikšmė.',
    'This value is not a valid time.' => 'Ši reikšmė nėra laikas.',
    'This value is not a valid URL.' => 'Ši reikšmė nėra tinkamas interneto adresas.',
    'The two values should be equal.' => 'Abi reikšmės turi būti identiškos.',
    'The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.' => 'Byla yra per didelė. Maksimalus dydis yra {{ limit }} {{ suffix }}.',
    'The file is too large.' => 'Byla per didelė.',
    'The file could not be uploaded.' => 'Byla negali būti įkelta.',
    'This value should be a valid number.' => 'Ši reikšmė turi būti skaičius.',
    'This value is not a valid country.' => 'Ši reikšmė nėra tinkama šalis.',
    'This file is not a valid image.' => 'Byla nėra paveikslėlis.',
    'This is not a valid IP address.' => 'Ši reikšmė nėra tinkamas IP adresas.',
    'This value is not a valid language.' => 'Ši reikšmė nėra tinkama kalba.',
    'This value is not a valid locale.' => 'Ši reikšmė nėra tinkama lokalė.',
    'This value is already used.' => 'Ši reikšmė jau yra naudojama.',
    'The size of the image could not be detected.' => 'Nepavyko nustatyti nuotraukos dydžio.',
    'The image width is too big ({{ width }}px). Allowed maximum width is {{ max_width }}px.' => 'Nuotraukos plotis per didelis ({{ width }}px). Maksimalus leidžiamas plotis yra {{ max_width }}px.',
    'The image width is too small ({{ width }}px). Minimum width expected is {{ min_width }}px.' => 'Nuotraukos plotis per mažas ({{ width }}px). Minimalus leidžiamas plotis yra {{ min_width }}px.',
    'The image height is too big ({{ height }}px). Allowed maximum height is {{ max_height }}px.' => 'Nuotraukos aukštis per didelis ({{ height }}px). Maksimalus leidžiamas aukštis yra {{ max_height }}px.',
    'The image height is too small ({{ height }}px). Minimum height expected is {{ min_height }}px.' => 'Nuotraukos aukštis per mažas ({{ height }}px). Minimalus leidžiamas aukštis yra {{ min_height }}px.',
    'This value should be the user\'s current password.' => 'Ši reikšmė turi sutapti su dabartiniu naudotojo slaptažodžiu.',
    'This value should have exactly {{ limit }} character.|This value should have exactly {{ limit }} characters.' => 'Ši reikšmė turi turėti lygiai {{ limit }} simbolį.|Ši reikšmė turi turėti lygiai {{ limit }} simbolius.|Ši reikšmė turi turėti lygiai {{ limit }} simbolių.',
    'The file was only partially uploaded.' => 'Failas buvo tik dalinai įkeltas.',
    'No file was uploaded.' => 'Nebuvo įkelta jokių failų.',
    'No temporary folder was configured in php.ini.' => 'Nėra sukonfiguruoto jokio laikino katalogo php.ini faile.',
    'Cannot write temporary file to disk.' => 'Nepavyko išsaugoti laikino failo.',
    'A PHP extension caused the upload to fail.' => 'PHP plėtinys sutrukdė failo įkėlimą ir jis nepavyko.',
    'This collection should contain {{ limit }} element or more.|This collection should contain {{ limit }} elements or more.' => 'Sąraše turi būti {{ limit }} arba daugiau įrašų.|Sąraše turi būti {{ limit }} arba daugiau įrašų.|Sąraše turi būti {{ limit }} arba daugiau įrašų.',
    'This collection should contain {{ limit }} element or less.|This collection should contain {{ limit }} elements or less.' => 'Sąraše turi būti {{ limit }} arba mažiau įrašų.|Sąraše turi būti {{ limit }} arba mažiau įrašų.|Sąraše turi būti {{ limit }} arba mažiau įrašų.',
    'This collection should contain exactly {{ limit }} element.|This collection should contain exactly {{ limit }} elements.' => 'Sąraše turi būti lygiai {{ limit }} įrašas.|Sąraše turi būti lygiai {{ limit }} įrašai.|Sąraše turi būti lygiai {{ limit }} įrašų.',
    'Invalid card number.' => 'Klaidingas kortelės numeris.',
    'Unsupported card type or invalid card number.' => 'Kortelės tipas nepalaikomas arba klaidingas kortelės numeris.',
    'This is not a valid International Bank Account Number (IBAN).' => 'Ši reišmė neatitinka tarptautinio banko sąskaitos numerio formato (IBAN).',
    'This value is not a valid ISBN-10.' => 'Ši reikšmė neatitinka ISBN-10 formato.',
    'This value is not a valid ISBN-13.' => 'Ši reikšmė neatitinka ISBN-13 formato.',
    'This value is neither a valid ISBN-10 nor a valid ISBN-13.' => 'Ši reikšmė neatitinka nei ISBN-10, nei ISBN-13 formato.',
    'This value is not a valid ISSN.' => 'Ši reišmė neatitinka ISSN formato.',
    'This value is not a valid currency.' => 'Netinkamas valiutos formatas.',
    'This value should be equal to {{ compared_value }}.' => 'Ši reikšmė turi būti lygi {{ compared_value }}.',
    'This value should be greater than {{ compared_value }}.' => 'Ši reikšmė turi būti didesnė už {{ compared_value }}.',
    'This value should be greater than or equal to {{ compared_value }}.' => 'Ši reikšmė turi būti didesnė už arba lygi {{ compared_value }}.',
    'This value should be identical to {{ compared_value_type }} {{ compared_value }}.' => 'Ši reikšmė turi būti identiška {{ compared_value_type }} {{ compared_value }}.',
    'This value should be less than {{ compared_value }}.' => 'Ši reikšmė turi būti mažesnė už {{ compared_value }}.',
    'This value should be less than or equal to {{ compared_value }}.' => 'Ši reikšmė turi būti mažesnė už arba lygi {{ compared_value }}.',
    'This value should not be equal to {{ compared_value }}.' => 'Ši reikšmė neturi būti lygi {{ compared_value }}.',
    'This value should not be identical to {{ compared_value_type }} {{ compared_value }}.' => 'Ši reikšmė neturi būti identiška {{ compared_value_type }} {{ compared_value }}.',
    'The image ratio is too big ({{ ratio }}). Allowed maximum ratio is {{ max_ratio }}.' => 'Nuotraukos santykis yra per didelis ({{ ratio }}). Didžiausias leistinas santykis yra {{ max_ratio }}.',
    'The image ratio is too small ({{ ratio }}). Minimum ratio expected is {{ min_ratio }}.' => 'Nuotraukos santykis yra per mažas ({{ ratio }}). Mažiausias leistinas santykis yra {{ min_ratio }}.',
    'The image is square ({{ width }}x{{ height }}px). Square images are not allowed.' => 'Nuotrauka yra kvadratinė ({{ width }}x{{ height }}px). Kvadratinės nuotraukos nėra leistinos.',
    'The image is landscape oriented ({{ width }}x{{ height }}px). Landscape oriented images are not allowed.' => 'Nuotrauka orientuota į plotį ({{ width }}x{{ height }}px). Nuotraukos orientuotos į plotį nėra leistinos.',
    'The image is portrait oriented ({{ width }}x{{ height }}px). Portrait oriented images are not allowed.' => 'Nuotrauka orientuota į aukštį ({{ width }}x{{ height }}px). Nuotraukos orientuotos į aukštį nėra leistinos.',
    'An empty file is not allowed.' => 'Failas negali būti tuščias.',
    'This form should not contain extra fields.' => 'Forma negali turėti papildomų laukų.',
    'The uploaded file was too large. Please try to upload a smaller file.' => 'Įkelta byla yra per didelė. bandykite įkelti mažesnę.',
    'The CSRF token is invalid. Please try to resubmit the form.' => 'CSRF kodas nepriimtinas. Bandykite siųsti formos užklausą dar kartą.',
    'fos_user.username.already_used' => 'Naudotojo vardas jau užimtas',
    'fos_user.username.blank' => 'Prašome įvesti naudotojo vardą',
    'fos_user.username.short' => '[-Inf,Inf]Naudotojo vardas per trumpas',
    'fos_user.username.long' => '[-Inf,Inf]Naudotojo vardas per ilgas',
    'fos_user.email.already_used' => 'El. paštas jau užimtas',
    'fos_user.email.blank' => 'Prašome įvesti el. paštą',
    'fos_user.email.short' => '[-Inf,Inf]El. paštas pert rumpas',
    'fos_user.email.long' => '[-Inf,Inf]El. paštas per ilgas',
    'fos_user.email.invalid' => 'El. paštas neteisingas',
    'fos_user.password.blank' => 'Prašome įvesti slaptažodį',
    'fos_user.password.short' => '[-Inf,Inf]Slaptažodis per trumpas',
    'fos_user.password.mismatch' => 'Įvesti skirtingi slaptažodžiai',
    'fos_user.new_password.blank' => 'Prašome įvesti naują slaptažodį',
    'fos_user.new_password.short' => '[-Inf,Inf]Naujas slaptažodis per trumpas',
    'fos_user.current_password.invalid' => 'Neteisingai įvestas slaptažodis',
    'fos_user.group.blank' => 'Prašome įvesti pavadinimą',
    'fos_user.group.short' => '[-Inf,Inf]Pavadinimas per trumpas',
    'fos_user.group.long' => '[-Inf,Inf]Pavadinimas per trumpas',
  ),
  'security' =>
  array (
    'An authentication exception occurred.' => 'Įvyko autentifikacijos klaida.',
    'Authentication credentials could not be found.' => 'Nepavyko rasti autentifikacijos duomneų.',
    'Authentication request could not be processed due to a system problem.' => 'Autentifikacijos užklausos nepavyko įvykdyti dėl sistemos klaidų.',
    'Invalid credentials.' => 'Klaidingi duomenys.',
    'Cookie has already been used by someone else.' => 'Slapukas buvo panaudotas kažkam kitam.',
    'Not privileged to request the resource.' => 'Neturite teisių pasiektį resursą.',
    'Invalid CSRF token.' => 'Neteisingas CSRF raktas.',
    'Digest nonce has expired.' => 'Prieigos kodas yra pasibaigęs.',
    'No authentication provider found to support the authentication token.' => 'Nerastas autentifikacijos tiekėjas, kuris palaikytų autentifikacijos raktą.',
    'No session available, it either timed out or cookies are not enabled.' => 'Sesija yra nepasiekiama, pasibaigė galiojimo laikas arba slapukai yra išjungti.',
    'No token could be found.' => 'Nepavyko rasti rakto.',
    'Username could not be found.' => 'Tokio naudotojo vardo nepavyko rasti.',
    'Account has expired.' => 'Paskyros galiojimo laikas baigėsi.',
    'Credentials have expired.' => 'Autentifikacijos duomenų galiojimo laikas baigėsi.',
    'Account is disabled.' => 'Paskyra yra išjungta.',
    'Account is locked.' => 'Paskyra yra užblokuota.',
  ),
  'FOSUserBundle' =>
  array (
    'group.edit.submit' => 'Atnaujinti grupę',
    'group.show.name' => 'Grupės vardas',
    'group.new.submit' => 'Sukurti grupę',
    'group.flash.updated' => 'Grupė atnaujinta',
    'group.flash.created' => 'Grupė sukurta',
    'group.flash.deleted' => 'Grupė ištrinta',
    'security.login.username' => 'Naudotojo vardas',
    'security.login.password' => 'Slaptažodis',
    'security.login.remember_me' => 'Atsiminti',
    'security.login.submit' => 'Prisijungti',
    'profile.show.username' => 'Naudotojo vardas',
    'profile.show.email' => 'El. paštas',
    'profile.edit.submit' => 'Atnaujinti',
    'profile.flash.updated' => 'Profilis atnaujintas',
    'change_password.submit' => 'Keisti slaptažodį',
    'change_password.flash.success' => 'Slaptažodis pakeistas',
    'registration.check_email' => 'El. pašto pranešimas išsiųstas adresu %email%. Jame rasite nuorodą, kurią aplankę, aktyvuosite savo paskyrą.',
    'registration.confirmed' => 'Sveikiname, jūsų paskyra aktyvuota.',
    'registration.back' => 'Grįžti atgal',
    'registration.submit' => 'Registruotis',
    'registration.flash.user_created' => 'Naudotojas sukurtas',
    'registration.email.subject' => 'Registracijos patvirtinimas',
    'registration.email.message' => 'Sveiki %username%!

Norėdami aktyvuoti savo paskyrą, apsilankykite adresu %confirmationUrl%

Pagarbiai,
Komanda.
',
    'resetting.password_already_requested' => 'Slaptažodžio keitimas šiam naudotojui jau buvo prašytas per paskutinias 24 valandas.',
    'resetting.check_email' => 'El. pašto pranešimas išsiųstas adresu %email%. Jame rasite nuorodą, kurią paspaudę, galėsite pakeisti savo slaptažodį.',
    'resetting.request.invalid_username' => 'Naudotojo vardas arba el. paštas "%username%" neegzistuoja.',
    'resetting.request.username' => 'Naudotojo vardas arba el. paštas',
    'resetting.request.submit' => 'Tęsti',
    'resetting.reset.submit' => 'Pakeisti slaptažodį',
    'resetting.flash.success' => 'Slaptažodis pakeistas',
    'resetting.email.subject' => 'Slaptažodžio keitimas',
    'resetting.email.message' => 'Sveiki %username%!

Norėdami pakeisti savo slaptažodį, apsilankykite adresu %confirmationUrl%

Pagarbiai,
Komanda.
',
    'layout.logout' => 'Atsijungti',
    'layout.login' => 'Prisijungti',
    'layout.register' => 'Registruotis',
    'layout.logged_in_as' => 'Prisijungęs kaip %username%',
    'form.group_name' => 'Grupės vardas',
    'form.username' => 'Naudotojo vardas*',
    'form.email' => 'El. paštas*',
    'form.current_password' => 'Dabartinis slaptažodis',
    'form.password' => 'Slaptažodis*',
    'form.password_confirmation' => 'Pakartoti slaptažodį*',
    'form.new_password' => 'Naujas slaptažodis',
    'form.new_password_confirmation' => 'Naujas slaptažodis (pakartoti)',
  ),
));
$catalogue->addFallbackCatalogue($catalogueLt);

return $catalogue;


text:
package api

import java.io.File
import java.util.UUID

import org.json4s.jackson.JsonMethods._
import org.json4s._
import org.json4s.JsonDSL._

import common.DsmoqSpec
import dsmoq.controllers.AjaxResponse
import dsmoq.persistence._
import dsmoq.services.json.DatasetData.{ Dataset, DatasetFile }
import dsmoq.services.json.GroupData.Group
import dsmoq.services.json.RangeSlice

class FileDownloadAuthorizationSpec extends DsmoqSpec {
  private val dummyFile = new File("../README.md")
  private val dummyUserId = "eb7a596d-e50c-483f-bbc7-50019eea64d7" // dummy 4
  private val dummyUserLoginParams = Map("d" -> compact(render(("id" -> "dummy4") ~ ("password" -> "password"))))
  private val anotherUserLoginParams = Map("d" -> compact(render(("id" -> "dummy2") ~ ("password" -> "password"))))

  "Authorization Test" - {
    "設定した権限にあわせてファイルをダウンロードできるか" - {
      "Deny*Deny*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.Deny, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Deny*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.Deny, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Deny*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.Deny, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Deny*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.Deny, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Limited*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Limited*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Limited*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Limited*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Full*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.FullPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Full*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.FullPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Full*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.FullPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Full*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.FullPublic, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Provider*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.Provider, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Provider*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.Provider, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Provider*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.Provider, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Provider*Deny" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.Provider, DefaultAccessLevel.Deny)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Deny*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.Deny, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Deny*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.Deny, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Deny*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.Deny, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Deny*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.Deny, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Limited*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Limited*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Limited*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Limited*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Full*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.FullPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Full*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.FullPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Full*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.FullPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Full*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.FullPublic, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Provider*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.Provider, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Limited*Provider*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.Provider, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Full*Provider*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.Provider, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Owner*Provider*Limited" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.Provider, DefaultAccessLevel.LimitedPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(403)
          }
        }
      }
      "Deny*Deny*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.Deny, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Limited*Deny*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.Deny, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Full*Deny*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.Deny, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Owner*Deny*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.Deny, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Deny*Limited*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Limited*Limited*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Full*Limited*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Owner*Limited*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.LimitedPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Deny*Full*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.FullPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Limited*Full*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.FullPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Full*Full*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.FullPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Owner*Full*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.FullPublic, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Deny*Provider*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Deny, GroupAccessLevel.Provider, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Limited*Provider*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.LimitedRead, GroupAccessLevel.Provider, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Full*Provider*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.FullPublic, GroupAccessLevel.Provider, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
      "Owner*Provider*Full" in {
        session {
          signIn()
          val datasetId = createPermissionedDataset(UserAccessLevel.Owner, GroupAccessLevel.Provider, DefaultAccessLevel.FullPublic)
          val uri = new java.net.URI(getFileUrl(datasetId))
          // ダミーユーザー時のダウンロードチェック AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          post("/api/signin", dummyUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // ゲストアクセス時のダウンロードチェック  AllowRead以上でダウンロード可
          post("/api/signout") { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
          // 何も権限を付与していないユーザーのダウンロードチェック ゲストと同じアクセス制限となる
          post("/api/signin", anotherUserLoginParams) { checkStatus() }
          get(uri.getPath) {
            status should be(200)
          }
        }
      }
    }
  }

  private def createPermissionedDataset(
    userAccessLevel: Int,
    groupAccessLevel: Int,
    guestAccessLevel: Int
  ): String = {
    // グループ作成
    val groupId = createGroup()
    val memberParams = Map("d" -> compact(render(Seq(("userId" -> dummyUserId) ~ ("role" -> GroupMemberRole.Member)))))
    post("/api/groups/" + groupId + "/members", memberParams) { checkStatus() }
    // データセット作成
    val datasetId = createDataset()
    setPermission(datasetId, groupId, userAccessLevel, groupAccessLevel, guestAccessLevel)
    datasetId
  }

  private def setPermission(
    datasetId: String,
    groupId: String,
    userAccessLevel: Int,
    groupAccessLevel: Int,
    guestAccessLevel: Int
  ): Unit = {
    // アクセスレベル設定(ユーザー/グループ)
    val accessLevelParams = Map(
      "d" -> compact(
        render(
          Seq(
            ("id" -> dummyUserId) ~ ("ownerType" -> JInt(OwnerType.User)) ~ ("accessLevel" -> JInt(userAccessLevel)),
            ("id" -> groupId) ~ ("ownerType" -> JInt(OwnerType.Group)) ~ ("accessLevel" -> JInt(groupAccessLevel))
          )
        )
      )
    )
    post("/api/datasets/" + datasetId + "/acl", accessLevelParams) { checkStatus() }
    // ゲストアクセスレベル設定
    val guestAccessLevelParams = Map("d" -> compact(render(("accessLevel" -> guestAccessLevel))))
    put("/api/datasets/" + datasetId + "/guest_access", guestAccessLevelParams) { checkStatus() }
  }

  private def getFileUrl(datasetId: String): String = {
    get(s"/api/datasets/${datasetId}/files") {
      val result = parse(body).extract[AjaxResponse[RangeSlice[DatasetFile]]]
      result.data.results(0).url.get
    }
  }

  private def createDataset(): String = {
    val files = Map("file[]" -> dummyFile)
    val params = Map("saveLocal" -> "true", "saveS3" -> "false", "name" -> "test1")
    post("/api/datasets", params, files) {
      checkStatus()
      parse(body).extract[AjaxResponse[Dataset]].data.id
    }
  }
  private def createGroup(): String = {
    val groupName = "groupName" + UUID.randomUUID.toString
    val params = Map("d" -> compact(render(("name" -> groupName) ~ ("description" -> "groupDescription"))))
    post("/api/groups", params) {
      checkStatus()
      parse(body).extract[AjaxResponse[Group]].data.id
    }
  }
}

redpajama_set_name: RedPajamaGithub


text:
public class PAPI_hw_info {
  public int ncpu;             /* Number of CPU's in an SMP Node */
  public int nnodes;           /* Number of Nodes in the entire system */
  public int totalcpus;        /* Total number of CPU's in the entire system */
  public int vendor;           /* Vendor number of CPU */
  public String vendor_string; /* Vendor string of CPU */
  public int model;            /* Model number of CPU */
  public String model_string;  /* Model string of CPU */
  public float revision;       /* Revision of CPU */
  public float mhz;            /* Cycle time of this CPU, *may* be estimated at
                                  init time with a quick timing routine */
  public PAPI_mh_info mem_hierarchy;  /* PAPI memory heirarchy description */

  public PAPI_hw_info() {
    // do nothing
  }

/*  public PAPI_hw_info(int nc, int nn, int tot, int v, String vs, int m,
     String ms, float r, float z)
  {
    ncpu = nc;
    nnodes = nn;
    totalcpus = tot;
    vendor = v;
    vendor_string = vs;
    model = m;
    model_string = ms;
    revision = r;
    mhz = z;
  }
*/
  public PAPI_hw_info(int nc, int nn, int tot, int v, String vs, int m,
     String ms, float r, float z, PAPI_mh_info mh)
  {
    ncpu = nc;
    nnodes = nn;
    totalcpus = tot;
    vendor = v;
    vendor_string = vs;
    model = m;
    model_string = ms;
    revision = r;
    mhz = z;
    mem_hierarchy=mh;
  }
}


text:
package com.open.chitchat.view;

import pl.droidsonroids.gif.GifImageView;

import com.open.chitchat.R;
import com.open.chitchat.model.FileHandlers;
import com.open.chitchat.utils.BaseDataUtils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.GridView;
import android.widget.PopupWindow;

public class ChatFaceGridView extends GridView implements android.widget.AdapterView.OnItemClickListener, android.widget.AdapterView.OnItemLongClickListener, android.view.View.OnTouchListener {
	private FileHandlers fileHandlers = FileHandlers.getInstance();

	private Context context;
	private ChatFaceGridView thisView;
	private ChatFaceView mChatFaceView;
	private FaceViewPager parent;
	private View currentView, popView;
	private int row, line, viewHeight, viewWidth, lastposition = -1;
	private float touchX, touchY;
	private PopupWindow mPopupWindow;
	private GifImageView imageView;
	private boolean isLongClick;
	private String type;

	public ChatFaceGridView(Context context, ChatFaceView mChatFaceView, FaceViewPager parent, String type) {
		super(context);
		this.context = context;
		this.mChatFaceView = mChatFaceView;
		this.parent = parent;
		this.type = type;
		this.thisView = this;
		if (type.equals("default")) {
			this.row = 7;
			this.line = 3;
		} else {
			this.row = 5;
			this.line = 2;
		}
		onCreate();
	}

	@SuppressLint("ClickableViewAccessibility")
	private void onCreate() {
		thisView.setCacheColorHint(getResources().getColor(R.color.transparent));
		thisView.setSelector(new ColorDrawable(Color.TRANSPARENT));
		thisView.setOnItemClickListener(this);
		thisView.setOnItemLongClickListener(this);
		thisView.setOnTouchListener(this);

		popView = LayoutInflater.from(context).inflate(R.layout.chat_face_pop, null);
		imageView = (GifImageView) popView.findViewById(R.id.gifImage);
		mPopupWindow = new PopupWindow(popView, LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
	}

	@Override
	public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
		if (mChatFaceView.mOnFaceSeletedListener != null) {
			mChatFaceView.mOnFaceSeletedListener.onFaceSeleted((String) view.getTag(R.id.tag_first));
		}
	}

	@Override
	public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
		if (this.parent != null) {
			this.parent.setTouchAble(false);
		}
		if (!"default".equals(type)) {
			isLongClick = true;
			currentView = view;
			judgePosition();
		}
		return true;
	}

	@SuppressLint("ClickableViewAccessibility")
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		touchX = event.getX();
		touchY = event.getY();
		if (event.getAction() == MotionEvent.ACTION_DOWN) {
			if (viewHeight == 0) {
				viewHeight = thisView.getHeight() / line;
				viewWidth = thisView.getWidth() / row;
			}
		} else if (event.getAction() == MotionEvent.ACTION_UP) {
			if (mPopupWindow.isShowing()) {
				mPopupWindow.dismiss();
			}
			if (parent != null) {
				parent.setTouchAble(true);
			}
			if (currentView != null) {
				currentView.setSelected(false);
			}
			lastposition = -1;
			isLongClick = false;
		} else if (event.getAction() == MotionEvent.ACTION_MOVE) {
			if (isLongClick) {
				judgePosition();
			}
		}
		return false;
	}

	private void judgePosition() {
		int position = 0;
		if (touchY >= 0 && touchY < viewHeight) {
			position = 0;
		} else if (touchY >= viewHeight && touchY < viewHeight * 2) {
			position = 1;
		} else if (touchY >= viewHeight * 2 && touchY < viewHeight * 3) {
			position = 2;
		}
		if (touchX >= 0 && touchX < viewWidth) {
			position *= row;
		} else if (touchX >= viewWidth && touchX < viewWidth * 2) {
			position = position * row + 1;
		} else if (touchX >= viewWidth * 2 && touchX < viewWidth * 3) {
			position = position * row + 2;
		} else if (touchX >= viewWidth * 3 && touchX < viewWidth * 4) {
			position = position * row + 3;
		} else if (touchX >= viewWidth * 4 && touchX < viewWidth * 5) {
			position = position * row + 4;
		} else if (touchX >= viewWidth * 5 && touchX < viewWidth * 6) {
			position = position * row + 5;
		} else if (touchX >= viewWidth * 6 && touchX < viewWidth * 7) {
			position = position * row + 6;
		}
		if (currentView != null && position != lastposition && position < thisView.getChildCount()) {
			if (mPopupWindow.isShowing()) {
				mPopupWindow.dismiss();
			}
			lastposition = position;
			currentView.setSelected(false);
			currentView = this.getChildAt(position);
			currentView.setSelected(true);
			String fileName = (String) currentView.getTag(R.id.tag_first);
			if (!"".equals(fileName) && fileName != null) {
				fileHandlers.getGifImage(fileName, imageView);
				mPopupWindow.showAsDropDown(currentView, -viewWidth / 2, -(viewHeight + (int) BaseDataUtils.dpToPx(140)));
			}
		}
	}
}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- Base application theme. -->
    <style name="DarkTheme" parent="@android:style/Theme">
       <!-- <item name="text_bg">@drawable/selector_text_bg_dark</item>
        <item name="bottom_bg">@drawable/bg_bottombar_dark</item>-->
    </style>
</resources>


text:
import Immutable from 'immutable';

export default class FrontendClientMetaDataModel extends Immutable.Record({
  runnerConnId: null,
  winId: null,
}) {
  constructor(properties) {
    if (!properties || !properties.runnerConnId || !properties.winId) {
      throw new Error('Required properties missing from frontend client metadata constructor.');
    }
    super(properties);
  }
}


text:
/*
 * Created on Aug 22, 2005
 */
package edu.psu.compbio.seqcode.gse.utils.preferences;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

import edu.psu.compbio.seqcode.gse.utils.EventSource;
import edu.psu.compbio.seqcode.gse.utils.Listener;

/**
 * @author tdanford
 */
public class PreferencesFrame extends JFrame {

    private PreferencesPanel pp;
    private EventSource.Default<PreferencesEvent> src;
	private JButton ok, cancel;

    public PreferencesFrame(PreferencesPanel temp) {
        super("Preferences");
        pp = temp;
        src = new EventSource.Default<PreferencesEvent>(this);

        Container c = (Container)getRootPane();
        c.setLayout(new BorderLayout());
        c.add(pp, BorderLayout.CENTER);

		JPanel buttons = new JPanel(); buttons.setLayout(new GridLayout(1, 2));
		ok = new JButton("Ok");
		cancel = new JButton("Cancel");
		buttons.add(ok); buttons.add(cancel);
		c.add(buttons, BorderLayout.SOUTH);

		ok.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				PreferencesEvent pe = new PreferencesEvent(PreferencesFrame.this, PreferencesEvent.OK);
				pp.saveValues();
				src.fireEvent(pe);
				dispose();
			}
		});

		cancel.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				PreferencesEvent pe = new PreferencesEvent(PreferencesFrame.this, PreferencesEvent.CANCEL);
				src.fireEvent(pe);
				dispose();
			}
		});

		addWindowListener(new WindowAdapter() {
			public void windowClosed(WindowEvent e) {
				PreferencesEvent pe = new PreferencesEvent(PreferencesFrame.this, PreferencesEvent.CANCEL);
				src.fireEvent(pe);
			}
		});

        setSize(400, 400);
		setLocation(100, 100);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setVisible(true);
		pack();
    }

    public PreferencesPanel getPanel() { return pp; }
    public void addEventListener(Listener<PreferencesEvent> l) { src.addEventListener(l); }
    public void removeEventListener(Listener<PreferencesEvent> l) { src.removeEventListener(l); }
}


text:
"""
Twisted Manhole: interactive interpreter and direct manipulation support for Twisted.
"""


text:
var app = app || {};

app.cards = Backbone.Model.extend({

    defaults: {
        id: "",
        title: "",
        descr: "",
        rating: "",
        responsible: "",
        stage: "todo"
    },

    idAttribute: "id",
    urlRoot: '/card',

    // i have this save method so that only the attributes given by http request are saved, instead of all attributes
    save: function (attrs, options) {
    	attrs = attrs || this.toJSON();
		options = options || {};

		// If model defines serverAttrs, replace attrs with trimmed version
		if (this.serverAttrs) attrs = _.pick(attrs, this.serverAttrs);

		// Move attrs to options
		options.attrs = attrs;

		// Call super with attrs moved to options
		Backbone.Model.prototype.save.call(this, attrs, options);
	}

});


text:
[![Build Status](https://travis-ci.org/jwbay/i18next-json-sync.svg?branch=master)](https://travis-ci.org/jwbay/i18next-json-sync)
[![npm](https://img.shields.io/npm/v/i18next-json-sync.svg)](https://www.npmjs.com/package/i18next-json-sync)
# i18next-json-sync

Keeps [i18next](https://github.com/i18next/i18next) JSON resource files in sync against a primary
language, including plural forms. When hooked up to a build process/CI server, ensures keys
added/removed from one language are correctly propagated to the other languages, reducing the chance
for missing or obselete keys, merge conflicts, and typos.

## Example
Given these files:
```
 locales
 ├── en.json
 ├── fr.json
 └── ru.json
```

```json
en.json
{
  "key_one": "value",
  "book": "book",
  "book_plural": "books"
}

fr.json
{
  "key_one": "french value"
}

ru.json
{
  "extra_key": "extra value"
}
```

`fr.json` and `ru.json` can be synced against `en.json`:

```js
import sync from 'i18next-json-sync'
sync({
  files: 'locales/*.json',
  primary: 'en'
});
```

resulting in:

```json
en.json
{
  "key_one": "value",
  "book": "book",
  "book_plural": "books"
}

fr.json
{
  "key_one": "french value",
  "book": "book",
  "book_plural": "books"
}

ru.json
{
  "key_one": "value",
  "book_0": "books",
  "book_1": "books",
  "book_2": "books"
}
```

`key_one` was left alone in fr.json since it's already localized, but `book` and `book_plural` were copied over.
An extraneous key in ru.json was deleted and keys from en.json copied over. Plurals are mapped between
languages according to the [i18next suffix rules](https://github.com/i18next/i18next/blob/520f5dccf8edecab5fb189eb0631201a08b940c7/src/PluralResolver.js).

> Note: Languages with only one suffix shared for singular and plural forms will not provide plural
mappings if they are used as the primary language.

This works on one folder at a time, but can deal with whatever the files glob returns. Files are
grouped into directories before processing starts. Folders without a 'primary' found are ignored.

## Usage

`$ npm install i18next-json-sync --save-dev`

#### In node.js

```js
import sync from 'i18next-json-sync';
//or in ES5 world:
//const sync = require('i18next-json-sync').default;

//defaults are inline:
sync({
  /** Audit files in memory instead of changing them on the filesystem and
    * throw an error if any changes would be made */
  check: false,
  /** Glob pattern for the resource JSON files */
  files: '**/locales/*.json',
  /** An array of glob patterns to exclude from the files search */
  excludeFiles: ['**/node_modules/**'],
  /** Primary localization language. Other language files will be changed to match */
  primary: 'en',
  /** Language files to create if they don't exist, e.g. ['es, 'pt-BR', 'fr'] */
  createResources: [],
  /** Space value used for JSON.stringify when writing JSON files to disk */
  space: 4,
  /** Line endings used when writing JSON files to disk. Either LF or CRLF */
  lineEndings: 'LF',
  /** Insert a final newline when writing JSON files to disk */
  finalNewline: false,
  /** Use empty string for new keys instead of the primary language value */
  newKeysEmpty: false
})
```

#### CLI

It can be installed globally and run with `sync-i18n`, but [package.json scripts](https://docs.npmjs.com/misc/scripts) are a better fit.

```json
{
  "name": "my-app",
  "scripts": {
    "i18n": "sync-i18n --files '**/locales/*.json' --primary en --languages es fr ja zh ko --space 2",
    "check-i18n": "npm run i18n -- --check"
  }
}
```

Then use `npm run i18n` to sync on the filesystem and `npm run check-i18n` to validate.

All options are available via CLI. Use `-h` or `--help` to get help output.

## License

[MIT](LICENSE)


text:
package org.gradle.api.internal.tasks.compile;

import org.codehaus.groovy.transform.GroovyASTTransformationClass;
import org.gradle.internal.classloader.TransformingClassLoader;
import org.gradle.internal.classpath.ClassPath;
import org.objectweb.asm.*;

import java.util.ArrayList;
import java.util.List;

/**
 * Transforms @GroovyASTTransformationClass(classes = {classLiterals}) into @GroovyASTTransformationClass([classNames]),
 * to work around GROOVY-5416.
 */
class GroovyCompileTransformingClassLoader extends TransformingClassLoader {
    private static final String ANNOTATION_DESCRIPTOR = Type.getType(GroovyASTTransformationClass.class).getDescriptor();

    public GroovyCompileTransformingClassLoader(ClassLoader parent, ClassPath classPath) {
        super(parent, classPath);
    }

    @Override
    protected byte[] transform(byte[] bytes) {
        // First scan for annotation, and short circuit transformation if not present
        ClassReader classReader = new ClassReader(bytes);

        AnnotationDetector detector = new AnnotationDetector();
        classReader.accept(detector, ClassReader.SKIP_DEBUG | ClassReader.SKIP_CODE);
        if (!detector.found) {
            return bytes;
        }

        ClassWriter classWriter = new ClassWriter(0);
        classReader.accept(new TransformingAdapter(classWriter), 0);
        bytes = classWriter.toByteArray();
        return bytes;
    }

    private static class AnnotationDetector extends ClassVisitor {
        private boolean found;

        private AnnotationDetector() {
            super(Opcodes.ASM5);
        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            if (desc.equals(ANNOTATION_DESCRIPTOR)) {
                found = true;
            }
            return null;
        }
    }

    private static class TransformingAdapter extends ClassVisitor {
        public TransformingAdapter(ClassWriter classWriter) {
            super(Opcodes.ASM5, classWriter);
        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            if (desc.equals(ANNOTATION_DESCRIPTOR)) {
                return new AnnotationTransformingVisitor(super.visitAnnotation(desc, visible));
            }
            return super.visitAnnotation(desc, visible);
        }

        private static class AnnotationTransformingVisitor extends AnnotationVisitor {
            private final List<String> names = new ArrayList<String>();

            public AnnotationTransformingVisitor(AnnotationVisitor annotationVisitor) {
                super(Opcodes.ASM5, annotationVisitor);
            }

            @Override
            public AnnotationVisitor visitArray(String name) {
                if (name.equals("classes")) {
                    return new AnnotationVisitor(Opcodes.ASM5){
                        @Override
                        public void visit(String name, Object value) {
                            Type type = (Type) value;
                            names.add(type.getClassName());
                        }
                    };
                } else if (name.equals("value")) {
                    return new AnnotationVisitor(Opcodes.ASM5) {
                        @Override
                        public void visit(String name, Object value) {
                            String type = (String) value;
                            names.add(type);
                        }
                    };
                } else {
                    return super.visitArray(name);
                }
            }

            @Override
            public void visitEnd() {
                if (!names.isEmpty()) {
                    AnnotationVisitor visitor = super.visitArray("value");
                    for (String name : names) {
                        visitor.visit(null, name);
                    }
                    visitor.visitEnd();
                }
                super.visitEnd();
            }
        }
    }
}


text:
package mx.nic.rdap.sql.objects;

import java.sql.ResultSet;
import java.sql.SQLException;

import mx.nic.rdap.core.db.VCard;

/**
 * Data access class for the {@link VCard} Object
 *
 */
public class VCardDbObj extends VCard implements DatabaseObject {

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * mx.nic.rdap.core.db.DatabaseObject#loadFromDatabase(java.sql.ResultSet)
	 */
	@Override
	public void loadFromDatabase(ResultSet resultSet) throws SQLException {
		setId(resultSet.getLong("vca_id"));
		setName(resultSet.getString("vca_name"));
		setCompanyName(resultSet.getString("vca_company_name"));
		setCompanyURL(resultSet.getString("vca_company_url"));
		setEmail(resultSet.getString("vca_email"));
		setVoice(resultSet.getString("vca_voice"));
		setCellphone(resultSet.getString("vca_cellphone"));
		setFax(resultSet.getString("vca_fax"));
		setJobTitle(resultSet.getString("vca_job_title"));
	}

}


text:
<?php

/**
 * Datatype of a field
 *
 * @phpstub
 *
 * @param resource $result_id
 * @param int $field_number
 *
 * @return string Returns the field type as a string, or false on error.
 */
function odbc_field_type($result_id, $field_number)
{
}