GithubHelp home page GithubHelp logo

statemachinetestingwithquickcheck's People

Contributors

dorinelfilip avatar

Watchers

avatar avatar

Forkers

g0lem thomas1995 draganrelu

statemachinetestingwithquickcheck's Issues

lambda 

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ExtendedDefaultRules #-}

import Control.Applicative
import Control.Monad
import Network.HTTP.Conduit    ( simpleHttp )
import qualified Data.ByteString.Lazy as L
import Database.MongoDB
    ( Select(select),
      close,
      master,
      insertMany,
      delete,
      access,
      host,
      connect,
      (=:) )
import Control.Monad.Trans (liftIO)
--import Control.Monad
import Data.Aeson
import Data.Text hiding (map)
import Data.Maybe


data RowListElement = RowListElement { id :: Value, abc :: Int } deriving Show
data RootJSONElement = RootJSONElement { offset :: Value, rows :: [RowListElement], total_rows :: Value, query :: Value, milis :: Value } deriving Show

instance FromJSON RowListElement where
    parseJSON (Object v) =
        RowListElement <$> v .: "_id" <*> v .: "abc"
    parseJSON _ = mzero

instance FromJSON RootJSONElement where
    parseJSON (Object v) =
        RootJSONElement <$> v .: "offset" <*> v .: "rows" <*> v .: "total_rows" <*> v .: "query" <*> v .: "millis"
    parseJSON _ = mzero


getIdsFromJSONString :: L.ByteString -> [Int]
getIdsFromJSONString s = result where
    decodedInput = decode s :: Maybe RootJSONElement
    xRowsList = rows $ fromJust decodedInput
    result = Prelude.map abc xRowsList

main :: IO ()
main = do
    apiBazaDate
    jsonString <- simpleHttp "http://127.0.0.1:28017/baseball/team/"
    let y = getIdsFromJSONString jsonString
    print y
    return ()

apiBazaDate = do
   pipe <- connect (host "127.0.0.1")
   e <- access pipe master "baseball" doAPIBazadade
   close pipe
   print e

doAPIBazadade = do
   clearTeams
   insertTeams

clearTeams = delete (select [] "team")

myInsertAbc list = insertMany $ map (\x -> ["abc" =: x])  list

insertTeams = insertMany "team" [
   ["abc" =: 123],
   ["abc" =: 456],
   ["abc" =: 789] ]

Importurile 

{-# LANGUAGE OverloadedStrings #-}

import Control.Applicative
import Control.Monad
import Data.Aeson
import Data.Text

2048 example 

import Data.List
import Data.List.Split
import Test.QuickCheck
import Debug.Trace

nextStep :: (Eq a, Num a) => [a] -> [a]
nextStep input =
    let
        len = length input
        list2 = filter (/= 0) input
        list3 = group list2
        list4 = map (chunksOf 2) list3
        list5 = concat list4
        list6 = map sum list5
    in
        take len $ list6 ++ (replicate len 0)

proprietate :: (Eq a, Num a) => [a] -> Bool
proprietate myList =
    let

        rarelen = length . (filter (==0))
        listamea = traceShow myList myList
    in
        rarelen myList <= (rarelen $ nextStep myList)

MongoDB Test 

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ExtendedDefaultRules #-}
{-# LANGUAGE NoMonomorphismRestriction #-}

import Test.QuickCheck         ( Arbitrary
                               , Args
                               , Gen
                               , Property
                               , arbitrary
                               , choose
                               , frequency
                               , maxSuccess
                               , quickCheckWith
                               , shrink
                               , stdArgs
                               , vectorOf
                               )
import Test.QuickCheck.Monadic ( assert
                               , monadicIO
                               , run
                               )

import qualified Data.Set as Set
import Control.Applicative
import Control.Monad
import Network.HTTP.Conduit    ( simpleHttp )
import qualified Data.ByteString.Lazy as L
import Database.MongoDB
    ( Select(select),
      close,
      master,
      insertMany,
      delete,
      access,
      host,
      connect,
      (=:) )
import Control.Monad.Trans (liftIO)
import Data.Aeson
import Data.Text hiding (map)
import Data.Maybe


data RowListElement = RowListElement { id :: Value, abc :: Int } deriving Show
data RootJSONElement = RootJSONElement { offset :: Value, rows :: [RowListElement], total_rows :: Value, query :: Value, milis :: Value } deriving Show

instance FromJSON RowListElement where
    parseJSON (Object v) =
        RowListElement <$> v .: "_id" <*> v .: "abc"
    parseJSON _ = mzero

instance FromJSON RootJSONElement where
    parseJSON (Object v) =
        RootJSONElement <$> v .: "offset" <*> v .: "rows" <*> v .: "total_rows" <*> v .: "query" <*> v .: "millis"
    parseJSON _ = mzero


getIdsFromJSONString :: L.ByteString -> [Int]
getIdsFromJSONString s = result where
    decodedInput = decode s :: Maybe RootJSONElement
    xRowsList = rows $ fromJust decodedInput
    result = Prelude.map abc xRowsList


addInDatabase list = do
   pipe <- connect (host "127.0.0.1")
   e <- access pipe master "qctest" $ addQuery list
   close pipe
   print e


addQuery list = do
   --clearTeams
   insertIds list


clearIds = delete (select [] "randids")

myInsertAbc list = insertMany "randids" $ map (\x -> ["abc" =: x])  list

insertIds list = myInsertAbc list

egalitate x y = x == y

--prorietate :: [Int] -> Property
checkProp list = do
  dbhandler <- addInDatabase list
  let inputSet = Set.fromList list
  restingJSON <- simpleHttp "http://127.0.0.1:28017/qctest/randids/"
  let restList = getIdsFromJSONString restingJSON
  let restingSet = Set.fromList restList
  return $ restingSet == inputSet

--checkProp2 :: [Int] -> Property
--checkProp2 list = monadicIO $ do
--  passed <- run $ do
--    let x = checkProp list
--  assert passed

customArgs :: Args
customArgs = ( stdArgs { maxSuccess = 1000000 } )

--main :: IO ()
--main = quickCheckWith customArgs checkProp

FromJust exception 

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ExtendedDefaultRules #-}

import Control.Applicative
import Control.Monad
import Network.HTTP.Conduit    ( simpleHttp )
import qualified Data.ByteString.Lazy as L
import Database.MongoDB
    ( Select(select),
      close,
      master,
      insertMany,
      delete,
      access,
      host,
      connect,
      (=:) )
import Control.Monad.Trans (liftIO)
--import Control.Monad
import Data.Aeson
import Data.Text
import Data.Maybe


data RowListElement = RowListElement { id :: Value, abc :: Int } deriving Show
data RootJSONElement = RootJSONElement { offset :: Value, rows :: [RowListElement], total_rows :: Value, query :: Value, milis :: Value } deriving Show

instance FromJSON RowListElement where
    parseJSON (Object v) =
        RowListElement <$> v .: "_id" <*> v .: "abc"
    parseJSON _ = mzero

instance FromJSON RootJSONElement where
    parseJSON (Object v) =
        RootJSONElement <$> v .: "offset" <*> v .: "rows" <*> v .: "total_rows" <*> v .: "query" <*> v .: "millis"
    parseJSON _ = mzero


getIdsFromJSONString :: L.ByteString -> [Int]
getIdsFromJSONString s = result where
    decodedInput = decode s :: Maybe RootJSONElement
    xRowsList = rows $ fromJust decodedInput
    result = Prelude.map abc xRowsList

main :: IO ()
main = do
    apiBazaDate
    jsonString <- simpleHttp "http://127.0.0.1:28017/baseball/team/"
    let y = getIdsFromJSONString jsonString
    print y
    return ()

apiBazaDate = do
   pipe <- connect (host "127.0.0.1")
   e <- access pipe master "baseball" doAPIBazadade
   close pipe
   print e

doAPIBazadade = do
   clearTeams
   insertTeams

clearTeams = delete (select [] "team")

insertTeams = insertMany "team" [
   ["abc" =: "123"],
   ["abc" =: "456"],
   ["abc" =: "789"] ]

Syntax 

import Test.QuickCheck         ( Arbitrary
                               , Args
                               , Gen
                               , Property
                               , arbitrary
                               , choose
                               , frequency
                               , maxSuccess
                               , quickCheckWith
                               , shrink
                               , stdArgs
                               , vectorOf
                               )

import Control.Applicative     ( (<$>) )

import Network.HTTP.Conduit    ( httpLbs
                               , parseUrl
                               , responseBody
                               , simpleHttp
                               , urlEncodedBody
                               , withManager
                               )

import Data.List
import Data.List.Split

data EvenInt =
 ZERO | TWO | FOUR | EIGHT 
 deriving (Eq, Show)

newtype EvenIntList =
    MkEvenIntList [EvenInt]
    deriving (Eq, Show)

instance Arbitrary EvenInt where
    arbitrary = arbitrary :: Gen EvenInt

instance Arbitrary EvenIntList where
        arbitrary = do
            len <- choose(30, 50)
            MkEvenIntList <$> ( vectorOf len $ (arbitrary :: Gen EvenInt) )

convertEvenIntToInt :: EvenInt -> Int
convertEvenIntToInt ZERO = 0
convertEvenIntToInt TWO = 2
convertEvenIntToInt FOUR = 4
convertEvenIntToInt EIGHT = 8

nextStep :: [Int] -> [Int]
nextStep inputList =
  let
    len = length inputList
    aux_list =
      map sum
      $ concat
      $ map (chunksOf 2)
      $ group
      $ filter (/= 0) inputList
  in
    take len $ aux_list ++ (replicate len 0)


proprietate :: (Eq a, Num a) => [a] -> Bool
proprietate myList =
    let

        rarelen = length . (filter (==0))
        listamea = myList
    in
        rarelen myList <= (rarelen $ nextStep myList)


customArgs :: Args
customArgs = ( stdArgs { maxSuccess = 1000000 } )


main :: IO ()
main = quickCheckWith customArgs proprietate

Baza de pornire 

{-# LANGUAGE OverloadedStrings #-}

import Control.Applicative
import Control.Monad
import Data.Aeson
import Data.Text

data OID = MkOID { oid :: Text } deriving Show
data RowListElement = MkRowListElement { id :: Value, abc :: Int } deriving Show

instance FromJSON OID where
  parseJSON (Object v) = MkOID <$> v .: "$oid"
  parseJSON _          = mzero

instance ToJSON OID where
  toJSON (MkOID oid) = object ["$oid" .= oid]

inputString = "{ \"$oid\": \"5548ed5171eab385baadf0a8\" }"

parseResult = decode inputString :: Maybe OID

inputList 

[0,0,2,4,0,4,4,8,0,0,2,0,2,0,2,0,2,0,8,8,8,0,0,0,8,8,0,0,8,8]

Mongo client code 

> use baseball
switched to db baseball
> db.team.insert( {'abc': 123} )
> db.team.insert( {'abc': 456} )
> db.team.insert( {'abc': 789} )

Progress 


{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ExtendedDefaultRules #-}

import Control.Applicative
import Control.Monad
import Network.HTTP.Conduit    ( simpleHttp )
import qualified Data.ByteString.Lazy as L
import Database.MongoDB
    ( Select(select),
      close,
      master,
      insertMany,
      delete,
      access,
      host,
      connect,
      (=:) )
import Control.Monad.Trans (liftIO)
--import Control.Monad
import Data.Aeson
import Data.Text
import Data.Maybe


data RowListElement = RowListElement { id :: Value, abc :: Int } deriving Show
data RootJSONElement = RootJSONElement { offset :: Value, rows :: [RowListElement], total_rows :: Value, query :: Value, milis :: Value } deriving Show

instance FromJSON RowListElement where
    parseJSON (Object v) =
        RowListElement <$> v .: "_id" <*> v .: "abc"
    parseJSON _ = mzero

instance FromJSON RootJSONElement where
    parseJSON (Object v) =
        RootJSONElement <$> v .: "offset" <*> v .: "rows" <*> v .: "total_rows" <*> v .: "query" <*> v .: "millis"
    parseJSON _ = mzero


getIdsFromJSONString :: L.ByteString -> [Int]
getIdsFromJSONString s = result where
    decodedInput = decode s :: Maybe RootJSONElement
    xRowsList = rows $ fromJust decodedInput
    result = Prelude.map abc xRowsList

main :: IO ()
main = do
    apiBazaDate
    jsonString <- simpleHttp "http://127.0.0.1:28017/baseball/team/"
    let y = getIdsFromJSONString jsonString
    print y
    return ()

apiBazaDate = do
   pipe <- connect (host "127.0.0.1")
   e <- access pipe master "baseball" doAPIBazadade
   close pipe
   print e

doAPIBazadade = do
   clearTeams
   insertTeams

clearTeams = delete (select [] "team")



insertTeams = insertMany "team" [
   ["abc" =: 123],
   ["abc" =: 456],
   ["abc" =: 789] ]

From Monad 

import Network.HTTP.Conduit
import qualified Data.ByteString.Lazy as L

main = simpleHttp "http://www.haskell.org/" >>= L.putStr

Working on it 



import Test.QuickCheck         ( Arbitrary
                               , Args
                               , Gen
                               , Property
                               , arbitrary
                               , choose
                               , frequency
                               , maxSuccess
                               , quickCheckWith
                               , shrink
                               , stdArgs
                               , vectorOf
                               )

import Control.Applicative     ( (<$>) )

import Network.HTTP.Conduit    ( httpLbs
                               , parseUrl
                               , responseBody
                               , simpleHttp
                               , urlEncodedBody
                               , withManager
                               )

import Data.List
import Data.List.Split

data EvenInt =
 ZERO | TWO | FOUR | EIGHT 
 deriving (Eq, Show)

convertEvenIntToInt :: EvenInt -> Int
convertEvenIntToInt ZERO = 0
convertEvenIntToInt TWO = 2
convertEvenIntToInt FOUR = 4
convertEvenIntToInt EIGHT = 8

newtype EvenIntList =
    MkEvenIntList [EvenInt]
    deriving (Eq, Show)

instance Arbitrary EvenInt where
    arbitrary = arbitrary :: Gen EvenInt

instance Arbitrary EvenIntList where
        arbitrary = do
            len <- choose(30, 50)
            MkEvenIntList <$> ( vectorOf len $ (arbitrary :: Gen EvenInt) )
            ---take len $ (arbitrary :: Gen EvenInt)

extractFromEvenIntList :: EvenIntList -> [EvenInt]
extractFromEvenIntList (MkEvenIntList list) = list

convertEvenIntToIntList :: EvenIntList -> [Int]
convertEvenIntToIntList list = map convertEvenIntToInt $ extractFromEvenIntList $ list

nextStep :: [Int] -> [Int]
nextStep inputList =
  let
    len = length inputList
    aux_list =
      map sum
      $ concat
      $ map (chunksOf 2)
      $ group
      $ filter (/= 0) inputList
  in
    take len $ aux_list ++ (replicate len 0)


proprietate ::  EvenIntList -> Bool
proprietate myList =
    let
        trueList = convertEvenIntToIntList myList
        rarelen = length . (filter (==0))
        listamea = trueList
        rarelen myList <= (rarelen $ nextStep trueList)


customArgs :: Args
customArgs = ( stdArgs { maxSuccess = 1000000 } )


main :: IO ()
main = quickCheckWith customArgs proprietate

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.