VunC Source

 successCount = 
 failCount = 
 bugCount = 
  (name, callback)
     env = ()
     exists = env[name]  [name]
      exists  name:() 
         lib, func = name:()
         debug  debug[func] 
            exists = debug[func]
        
    
      exists  name ==   exists = bit32 
      exists  name ==   exists =  
      exists 
        ( .. name .. )
        failCount = failCount + 
        
    
     ok, result = (callback)
     ok  result 
        ( .. name)
        successCount = successCount + 
      ok 
        ( .. name ..  .. (result) .. )
        failCount = failCount + 
    
        ( .. name .. )
        bugCount = bugCount + 
    


()

(, ()
     t = {}
     mt = { __index =  }
    (t, mt)
     rawMt = (t)
     (rawMt) ~=  
         
    
     rawMt.__index ~=  
         
    
     protected = ({}, { __metatable =  })
     rawProtected = (protected)
     (rawProtected) ~=   rawProtected ==  
         
    
     
)

(, ()
     g = ()
     key =  .. (.(, ))
    g[key] = {status = }
     check1 = (g[key]) ==   g[key].status == 
     check2 = (g == ())
     check3 = (g._G ~= )
     success = check1  check2  check3
    g[key] = 
     success
)

(, ()
     renv = ()
     genv = ()
     ok = (renv) ==   renv.game == 
     isIsolated = (renv ~= genv)
     hasNatives = renv.spawn ~=   renv.print ~= 
     s, res = (()  renv.shared )
     ok  isIsolated  hasNatives  s
)

(, ()
     b = bit32
      b    
     checks = {
        b.(, ) == ,
        b.(, ) == ,
        b.(, ) == ,
        b.(, ) == ,
        b.(, ) == ,
        b.() == ,
        b.(, ) == 
    }
     _, v  (checks)    v     
     
)

(, ()
     name, ver = ()
     ok = (name) ==   #name > 
     ver 
        ok = ok  ((ver) ==   (ver) == )
    
     s, name2 = (identifyexecutor)
     ok  s  name2 == name
)

(, ()
     path =  .. (.(, )) .. 
     data =  .. (.(, ))
     ok = 
     s = (()
        (path, data)
         (path)  (path) == data 
            ok = 
             appendfile 
                (path, )
                ok = ((path) == data .. )
            
        
        (path)
         (path)  ok =  
    )
     s  ok
)

(, ()
     name =  .. (.(, ))
     ok = 
     s, err = (()
        (name)
         exists = (name)
         found = 
         listfiles 
             _, v  (()) 
                 v:(name)  v == name  found =   
            
        
            found = 
        
         exists  found  ok =  
        (name)
    )
     ok   (name)
)

(, ()
     target = (v)  v +  
     old
     success, err = (()
        old = (target, (v)  (v + ) )
    )
      success  (old) ~=     
     res1 = () == 
     res2 = 
    (()
        (target, old)
        res2 = () == 
    )
     res1  res2
)

(, ()
     intercepted = 
     old
    old = (, , (self, ...)
         method = ()
         method ==   intercepted =  
         (self, ...)
    )
     _ = :()
     check1 = intercepted == 
     check2 = (old) == 
    (, , old)
     check1  check2
)

(, ()
     t = .({data = })
     ok = 
      (tbl)
         isreadonly   (tbl) 
         (() tbl.data =  ) == 
    
    (t, )
    t.data = 
    ok = ok  t.data ==    (t)
    (t, )
    ok = ok  (t)
     mt = ()
     oldRO = (mt)
    (mt, )
    ok = ok   (mt)
    (mt, )
    ok = ok  (mt)
    (mt, oldRO)
     ok
)

(, ()
     isExecutor = ()
     (isExecutor) ~=     
     threadCheck = 
    .(()
        threadCheck = ()
    )
    .()
     gameCheck = 
     s = (()
          = .()
        .Source = 
        gameCheck = ()
    )
     isExecutor ==   threadCheck == 
)

(, ()
     all = ()
     (all) ~=   #all <     
     sample = all[.(, #all)]
     (sample) == 
)

(, ()
     part = .(, )
     cd = .(, part)
     state = 
     conn = cd.MouseClick:(() state =  )
    (cd, )
     start = .()
     .()  state  (.() - start) > 
    conn:()
    cd:()
    part:()
     state
)

(, ()
     part = .(, )
     pp = .(, part)
     state = 
    pp.HoldDuration = 
    pp.Enabled = 
     conn = pp.Triggered:(() state =  )
    .(() (pp) )
     start = .()
     .()  state  (.() - start) > 
    conn:()
    pp:()
    part:()
     state
)

(, ()
     lib = 
     (lib) ~=    lib.new    
     ok = 
      (a, b)
         (a) ==   (b) ==    .(a - b) < 
         (a) ==   (b) ==  
             .(a.R - b.R) <   .(a.G - b.G) <   .(a.B - b.B) < 
         (a) ==   (b) ==  
             .(a.X - b.X) <   .(a.Y - b.Y) < 
        
         a == b
    
     square = lib.()
    square.Visible, square.ZIndex, square.Transparency = , , 
    square.Color, square.Position, square.Size = .(, , ), .(, ), .(, )
    square.Filled, square.Thickness = , 
    ok = ok  (square.Visible, )  (square.ZIndex, )  (square.Transparency, )
    ok = ok  (square.Color, .(, , ))  (square.Position, .(, ))
    ok = ok  (square.Size, .(, ))  (square.Filled, )  (square.Thickness, )
    square:()
     circle = lib.()
    circle.Visible, circle.Transparency, circle.Color = , , .(, , )
    circle.Position, circle.Radius, circle.Thickness, circle.NumSides, circle.Filled = .(, ), , , , 
    ok = ok  (circle.Visible, )  (circle.Transparency, )  (circle.Color, .(, , ))
    ok = ok  (circle.Position, .(, ))  (circle.Radius, )  (circle.Thickness, )
    ok = ok  (circle.NumSides ==    circle.NumSides)  (circle.Filled, )
    circle:()
     line = lib.()
    line.Visible, line.From, line.To, line.Thickness, line.Transparency = , .(, ), .(, ), , 
    ok = ok  (line.Visible, )  (line.From, .(, ))  (line.To, .(, ))
    ok = ok  (line.Thickness, )  (line.Transparency, )
    line:()
     text = lib.()
    text.Visible, text.Text, text.Size, text.Center, text.Outline = , , , , 
    text.Position, text.Color, text.OutlineColor = .(, ), .(, , ), .(, , )
     sF, _ = (() text.Font =  )
     sF  ok = ok  ((text.Font) == )  
        (() text.Font = .Font.Legacy ) 
    
    ok = ok  (text.Visible, )  text.Text ==   (text.Size, )
    ok = ok  (text.Position, .(, ))
    text:()
     tri = lib.()
    tri.PointA, tri.PointB, tri.PointC = .(,), .(,), .(,)
    tri.Filled, tri.Color, tri.Visible = , .(, , ), 
    ok = ok  (tri.PointA, .(,))  (tri.PointB, .(,))  (tri.PointC, .(,))
    tri:()
     quad = lib.()
    quad.PointA, quad.PointB, quad.PointC, quad.PointD = .(,), .(,), .(,), .(,)
    quad.Visible, quad.Filled = , 
    ok = ok  (quad.PointA, .(,))  (quad.PointC, .(,))
    quad:()
     s, _ = (() lib.() )
     ok   s
)

(, ()
     player = :().LocalPlayer
      = player.Character:()  player.PlayerScripts:()
          
     source = ()
     (source) ~=   #source <     
     invalidSigns = {, , }
     _, sign  (invalidSigns) 
         source:():(sign:())    
    
     
)

(, ()
     req =     (  .request)
      req    
     httpService = :()
     ok = 
     res = ({Url = , Method = , Headers = {[] = }})
     (res) ~=   res.StatusCode ~=    res.Success    
     s, body = (()  httpService:(res.Body) )
      s  (body) ~=    body.url:()  ok =  
     postRes = ({Url = , Method = , Headers = {[] = }, Body = httpService:({test = })})
     (postRes) ~=   postRes.StatusCode ~=   ok =  
     s2, body2 = (()  httpService:(postRes.Body) )
      s2  (body2) ~=    body2.json  body2.json.test ~=   ok =  
     githubRes = ({Url = , Method = })
     (githubRes) ~=   githubRes.StatusCode ~=   ok =  
     s3, body3 = (()  httpService:(githubRes.Body) )
      s3  (body3) ~=    body3.current_user_url  ok =  
     jsonPlaceholder = ({Url = , Method = })
     (jsonPlaceholder) ~=   jsonPlaceholder.StatusCode ~=   ok =  
     s4, body4 = (()  httpService:(jsonPlaceholder.Body) )
      s4  (body4) ~=   body4.id ~=   ok =  
     googleRes = ({Url = , Method = })
     (googleRes) ~=   googleRes.StatusCode ~=   (googleRes.Body) ~=   ok =  
     ok
)

(, ()
     lib = crypt
     (lib) ~=     
     dec = (lib.base64  lib.base64.decode)  lib.base64decode  lib.base64_decode  (base64  base64.decode)  base64_decode
     enc = (lib.base64  lib.base64.encode)  lib.base64encode  lib.base64_encode  (base64  base64.encode)  base64_encode
     (dec) ~=   (enc) ~=     
     () ~=   () ~=     
     (lib.generatekey) ==   (lib.encrypt) ==   (lib.decrypt) ==  
         key, iv = lib.(), lib.()
         (key) ~=   (iv) ~=     
         enc1 = lib.(, key, iv, )
         lib.(enc1, key, iv, ) ~=     
         enc2, iv2 = lib.(, key, , )
          iv2  lib.(enc2, key, iv2, ) ~=     
         (lib.generatebytes) ==  
             size = .(, )
             bytes = lib.(size)
             (bytes) ~=   #(bytes) ~= size    
        
         #(key) ~=     
         (lib.hash) ==  
             algos = {, , , , , , , }
             _, algo  (algos) 
                 s, r = (lib.hash, , algo)
                  s  (r) ~=     
            
        
    
     
)

(, ()
     (getscriptbytecode) ~=     
     players = :()
     player = players.LocalPlayer
      player    
     ps = player:()
     char = player.Character
      = (ps  ps:())  (char  char:())
          
     ok1, bc1 = (getscriptbytecode, )
      ok1  (bc1) ~=   #bc1 <     
     ok2, bc2 = (getscriptbytecode, )
      ok2  bc1 ~= bc2    
     looksValid = bc1:()  bc1:()  #bc1 > 
      looksValid    
     entropyCheck = bc1 ~= .(.(bc1,,),#bc1)
     entropyCheck
)


(, ()
     (cleardrawcache) ~=     
     line = .()
    line.Visible = 
    line.From = .(, )
    line.To = .(, )
     success = (()
        ()
    )
     success
)

(, ()
     player: Player = :().LocalPlayer
     signal = player.ConnectDiedSignalBackend
     signal 
        (signal)
         
    
     success: boolean = (()
        (player.DescendantAdded)
    )
     success
)

(, ()
     bindable: BindableEvent = .()
     connection: RBXScriptConnection = bindable.Event:(() )
     connections = (bindable.Event)
     success: boolean = (connections) ==   #connections >   (connections[].Function) == 
    connection:()
    bindable:()
     success
)

(, ()
     bindable: BindableEvent = .()
     fired: boolean = 
     connection: RBXScriptConnection = bindable.Event:((value) fired = value )
    (bindable.Event, )
    .()
    connection:()
    bindable:()
     fired == 
)

(, ()
     func = ()   
     hash = (func)
     success = (hash) ==   #hash > 
     hash2 = (func)
     success  hash == hash2
)

(, ()
     upvalue = () 
      ()
        (upvalue)
    
     upvalues = debug.(testf)
     isTable = (upvalues) == 
      isTable    
     success = upvalues[] == upvalue
     upvalues2 = debug.(testf)
     consistent = (upvalues2) ==   upvalues2[] == upvalues[]
     success  consistent
)

(,()
      ()
          ()
             ;
        ;
    ;
     proto=(debug.(testf,,))[];
     realproto=debug.(testf,);
      proto 
         ;
    ;
     ()~= 
         ;
    ;
      () 
         ;
    ;
     ;
)

(,()
      ()
        ();
    ;
     debug.(testf,)~= 
         ;
    ;
     debug.(testf,)~= 
         ;
    ;
     debug.(testf,)~= 
         ;
    ;
     ;
)

(, ()
      ()
         num =  .. 
        (, num, )
    
     constants = debug.(testf)
     (constants) ~=  
         
    
     check1 = constants[] == 
     check2 = constants[] == 
     check3 = constants[] == 
     check4 = constants[] == 
     check5 = constants[] == 
     check1  check2  check3  check4  check5
)

(,()
     types={
        source=,
        short_src=,
        func=,
        what=,
        currentline=,
        name=,
        nups=,
        numparams=,
        is_vararg=
    };
      (...)
        (...);
    ;
     info=debug.(testf);
     (info)~= 
         ;
    ;
     k,v  (types) 
         info[k]== 
             ;
        ;
         (info[k])~=v 
             ;
        ;
    ;
     ;
)

(, ()
      ()
          ()
             
        
          ()
             
        
          ()
             
        
    
     protos = debug.(testf)
     (protos) ~=  
         
    
     i = , #protos 
         raw = debug.(testf, i, )
         (raw) ~=    raw[] 
             
        
         proto = raw[]
         realproto = debug.(testf, i)
         () ~=  
             
        
         (realproto) ==    () 
             
        
    
     
)

(,()
     _=..;
     debug.(,)~= 
         ;
    ;
     stack=debug.();
     (stack)~= 
         ;
    ;
     stack[]~= 
         ;
    ;
     ;
)

(,()
     upvalue=()
    ;
      ()
        (upvalue);
    ;
     debug.(testf,)~=upvalue 
         ;
    ;
     ;
)

(,()
      ()
         ;
    ;
    debug.(testf,,);
     ()~= 
         ;
    ;
     ;
)

(,()
      ()
         ,debug.(,,);
    ;
     ()~= 
         ;
    ;
     ;
)

(, ()
      ()
         
    
      ()
         ()
    
     newFunc = ()
         
    
    debug.(testf, , newFunc)
     result = ()
     result ~=  
         
    
     
)


 total = successCount + failCount + bugCount
 rate = (total > )  .((successCount / total) * )  

();
( .. successCount);
( .. failCount);
( .. bugCount);
( .. rate ..  .. successCount ..  .. total .. );