test.c

Go to the documentation of this file.

/*
 * finflect - Algorithms and tools for inflecting Finnish nouns
 * Copyright (C) 2004, 2005  The FinFlect Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * For the complete legal text of the GNU Lesser General Public License,
 * see the file LICENSE. For a complete list of authors and copyright
 * holders, see the file AUTHORS.
 */

/**
 * @file test.c Some random tests
 * @todo Remove me
 */

#include <stdlib.h>
#include <stdio.h>

#include "ffstring.h"
#include "ffword.h"
#include "ffutil.h"
#include "ffregex.h"
#include "finflect.h"
/**
 * ffpriv_genitive.h is for internal use only
 */
#include "ffpriv_basic_cases.h"
#include "ffpriv_exterior_local_cases.h"
#include "ffpriv_genitive_stem.h"
#include "ffpriv_ie_vowel_change.h"
#include "ffpriv_ss_abnormal.h"

int main(int argv, char** args)
{
  ffstring kissa, issa, kissa2;
  ffstring koira, APINA, apina;
  ffstring tatar;
  ffword tatarw, typpi, kuningas;
  ffint32 j;
  ffchar *perkele, *perkeletta;
  
  if (ffstring_create("kissa", &kissa)) { return 1; }
  printf("pla(%d): %s\n", kissa.len, kissa.str);
  
  if (ffstring_tail(&kissa, 4, &issa)) { return 1; }
  printf("prrrriiii(%d): %s\n", issa.len, issa.str);

  if (ffstring_rfe(&kissa,1,"oissa")) { return 1; }
  printf("pla(%d): %s\n", kissa.len, kissa.str);

  if(ffstring_append(&kissa, "an")) { return 1; }
  printf("pla(%d): %s\n", kissa.len, kissa.str);

  if(ffstring_dfe(&kissa, 2)) { return 1; }
  printf("pla(%d): %s\n", kissa.len, kissa.str);

  if(ffstring_copy(&kissa, &koira)) { return 1; }
  if(ffstring_append(&kissa, "abc")) { return 1; }
  if(ffstring_append(&koira, "cba")) { return 1; }
  printf("pla(%d): %s\n", kissa.len, kissa.str);
  printf("pla(%d): %s\n", koira.len, koira.str);
  
  printf("uga: %d\n", ffstring_compare_ff(&kissa, &koira));
  printf("uga: %d\n", ffstring_compare_ff(&koira, &kissa));
  
  /* for (i = koira.str; i < koira.str + koira.len; ++i)
  printf("plagu(%c): %d\n", *i, ff_is_consonant(*i)); */

  if(ffstring_create("APINA", &APINA)) { return 1; }
  printf("pör(%d): %s\n", APINA.len, APINA.str);
  
  if(ffstring_lower(&APINA, &apina)) { return 1; }
  printf("pör(%d): %s\n", apina.len, apina.str);

  printf("uga: %d\n", ffstring_compare_ff(&apina, &APINA));
  printf("uga: %d\n", ffstring_compare_ff_ci(&apina, &APINA));
    
  if(ffstring_tolower(&APINA)) { return 1; }
  printf("pör(%d): %s\n", APINA.len, APINA.str);   
    
  ffstring_delete(&kissa);
  ffstring_delete(&issa);
  ffstring_delete(&koira);
  ffstring_delete(&APINA);
  ffstring_delete(&apina);
  
  if (ffstring_create("kevät",&tatar)) { return 1; }
  printf("tat(%d): %s\n", tatar.len, tatar.str);
  
  tatarw.data = tatar;
  /**
   * @todo ffpriv_genitive_stem is for internal use only
   */
  
  
  if (ffpriv_adessive_singular(&tatarw)) { return 1; }
  printf("tat(%d): %s\n", tatar.len, tatar.str);
  
  ffstring_delete(&tatar);
  
  if(ffstring_create("aaaaakissaaaaaa", &kissa2)) {return 1;}
  
  printf("burarum(%d): %s\n", kissa2.len, kissa2.str);
  
  printf("umpah(kissa): %d\n", ffregex_match("kissa", &kissa2));
  printf("umpah(sa+): %d\n", ffregex_match("sa+", &kissa2));
  printf("umpah_ci(KISSA): %d\n", ffregex_match_ci("KISSA", &kissa2));
  
  printf("humpa(koira): %d\n", ffregex_match("koira", &kissa2));
  printf("humpa(ö+): %d\n", ffregex_match("ö+", &kissa2));
  
  ffregex_replace("kissa", "koira", &kissa2);
  
  printf("parum(%d): %s\n", kissa2.len, kissa2.str);
  
  ffregex_replace("aa(koira)aa", "bb${1}bb", &kissa2);
  
  printf("paparum(%d): %s\n", kissa2.len, kissa2.str);
  
  ffstring_delete(&kissa2);
  
  ffstring_create("typpi", &typpi.data);
  ffpriv_ie_partitive(&typpi);
  
  printf("burarum(%d): %s\n", typpi.data.len, typpi.data.str);
  
  ffstring_delete(&typpi.data);
  
  ffstring_create("kuningas", &kuningas.data);
  ffpriv_ss_genitive(&kuningas);
  printf("burarum(%d): %s\n", kuningas.data.len, kuningas.data.str);
  ffstring_delete(&kuningas.data);

  perkele = "perkele";
  perkeletta = ff_partitive_singular(perkele);
  printf("aargh: %s\n", perkele);
  printf("ieaargh: %s\n", perkeletta);
  free(perkeletta);

  if ((j = ffstring_instcount()))
  {
    printf("Unbalanced number of strings: %d\n", j);
    return 1;
  }

  return EXIT_SUCCESS;
}

---